alepha 0.8.1 → 0.9.0

package/server/cache.d.ts

@@ -1,48 +1,45 @@
-import { Cache, CacheDescriptorOptions, CacheDescriptorProvider } from "alepha/cache";
-import { ServerHandler, ServerRequestConfig } from "alepha/server";
-import * as _alepha_core1 from "alepha";
-import { Alepha, Module, OPTIONS } from "alepha";
+import * as _alepha_cache0 from "alepha/cache";
+import { CacheDescriptorOptions } from "alepha/cache";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha } from "alepha";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
+import { RequestConfigSchema, ServerRequest, ServerRoute } from "alepha/server";
 
 //#region src/providers/ServerCacheProvider.d.ts
 declare module "alepha/server" {
   interface ServerRoute {
     cache?: ServerRouteCache;
   }
-  interface ActionDescriptor {
+  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
   }
 }
 declare class ServerCacheProvider {
-  protected readonly log: _alepha_core1.Logger;
+  protected readonly log: _alepha_core0$1.Logger;
   protected readonly alepha: Alepha;
-  protected readonly cacheProvider: CacheDescriptorProvider;
   protected readonly time: DateTimeProvider;
-  protected readonly caches: Map<ServerHandler, RouteCache>;
-  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
-  readonly onRoute: _alepha_core1.HookDescriptor<"server:onRoute">;
-  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  readonly onSend: _alepha_core1.HookDescriptor<"server:onResponse">;
+  protected readonly cache: _alepha_cache0.CacheDescriptorFn<RouteCacheEntry, any[]>;
   generateETag(content: string): string;
-  invalidate(route: RouteLike): Promise<void>;
-  protected getCacheByRoute(route: RouteLike): RouteCache | undefined;
-  protected createCacheKey(args: ServerRequestConfig): string;
+  invalidate(route: ServerRoute): Promise<void>;
+  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  protected readonly onSend: _alepha_core0$1.HookDescriptor<"server:onResponse">;
+  protected getCacheOptions(cache: ServerRouteCache): {
+    provider?: (_alepha_core0$1.InstantiableClass<_alepha_cache0.CacheProvider> | "memory") | undefined;
+    name?: string | undefined;
+    ttl?: DurationLike | undefined;
+    disabled?: boolean | undefined;
+  };
+  protected createCacheKey(route: ServerRoute, args?: ServerRequest): string;
 }
 type ServerRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
-type RouteCache = Cache<{
+interface RouteCacheEntry {
   contentType?: string;
   body: string;
   status?: number;
   lastModified: string;
   hash: string;
-}>;
-type RouteLike = {
-  [OPTIONS]: {
-    handler?: ServerHandler;
-  };
-} | {
-  handler?: ServerHandler;
-};
+}
 //#endregion
 //#region src/index.d.ts
 /**
@@ -73,10 +70,7 @@ type RouteLike = {
  * @see {@link ServerCacheProvider}
  * @module alepha.server.cache
  */
-declare class AlephaServerCache implements Module {
-  readonly name = "alepha.server.cache";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaServerCache: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion

package/server/compress.d.ts

@@ -1,6 +1,7 @@
+import * as _alepha_core0 from "alepha";
+import { HookDescriptor } from "alepha";
 import { ServerResponse } from "alepha/server";
 import { Transform } from "node:stream";
-import { Alepha, HookDescriptor, Module } from "alepha";
 
 //#region src/providers/ServerCompressProvider.d.ts
 declare class ServerCompressProvider {
@@ -8,19 +9,27 @@ declare class ServerCompressProvider {
     compress: (...args: any[]) => Promise<Buffer>;
     stream: (options?: any) => Transform;
   } | undefined>;
+  options: ServerCompressProviderOptions;
   readonly onResponse: HookDescriptor<"server:onResponse">;
   protected isAllowedContentType(contentType: string | undefined): boolean;
   protected compress(encoding: keyof typeof (void 0).compressors, response: ServerResponse): Promise<void>;
   protected getParams(encoding: keyof typeof (void 0).compressors): Record<number, any>;
   protected setHeaders(response: ServerResponse, encoding: keyof typeof (void 0).compressors): void;
 }
+interface ServerCompressProviderOptions {
+  allowedContentTypes: string[];
+}
+//# sourceMappingURL=ServerCompressProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
-declare class AlephaServerCompress implements Module {
-  readonly name = "alepha.server.compress";
-  readonly $services: (alepha: Alepha) => void;
-}
+/**
+ * Plugin for Alepha Server that provides server-side compression capabilities.
+ *
+ * Compresses responses using gzip, brotli, or zstd based on the `Accept-Encoding` header.
+ */
+declare const AlephaServerCompress: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { AlephaServerCompress, ServerCompressProvider };
+export { AlephaServerCompress, ServerCompressProvider, ServerCompressProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/server/cookies.d.ts

@@ -1,18 +1,53 @@
-import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, Static, TObject, TOptional, TSchema, TString } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, Static, TSchema } from "alepha";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
+//#region src/providers/ServerCookiesProvider.d.ts
+declare const envSchema: _alepha_core0$1.TObject<{
+  /**
+   *  A 32-byte secret key used for cookie encryption and signing. MUST be set for `encrypt` or `sign` to work.
+   */
+  COOKIE_SECRET: _alepha_core0$1.TOptional<_alepha_core0$1.TString>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare class ServerCookiesProvider {
+  protected readonly alepha: Alepha;
+  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly env: {
+    COOKIE_SECRET?: string | undefined;
+  };
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly ALGORITHM = "aes-256-gcm";
+  protected readonly IV_LENGTH = 16;
+  protected readonly AUTH_TAG_LENGTH = 16;
+  protected readonly SIGNATURE_LENGTH = 32;
+  readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core0$1.HookDescriptor<"server:onSend">;
+  protected getCookiesFromContext(cookies?: Cookies): Cookies;
+  getCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, contextCookies?: Cookies): Static<T> | undefined;
+  setCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, data: Static<T>, contextCookies?: Cookies): void;
+  deleteCookie<T extends TSchema>(name: string, contextCookies?: Cookies): void;
+  protected encrypt(text: string): string;
+  protected decrypt(encryptedText: string): string;
+  secretKey(): string;
+  protected sign(data: string): string;
+  protected parseRequestCookies(header: string): Record<string, string>;
+  protected serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
+}
+//#endregion
 //#region src/descriptors/$cookie.d.ts
-declare const KEY = "COOKIE";
 /**
-* Declares a type-safe, configurable HTTP cookie.
-* This descriptor provides methods to get, set, and delete the cookie
-* within the server request/response cycle.
-*/
+ * Declares a type-safe, configurable HTTP cookie.
+ * This descriptor provides methods to get, set, and delete the cookie
+ * within the server request/response cycle.
+ */
 declare const $cookie: {
   <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
-  [KIND]: string;
+  [KIND]: typeof CookieDescriptor;
 };
-// ---------------------------------------------------------------------------------------------------------------------
 interface CookieDescriptorOptions<T extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
   schema: T;
@@ -37,22 +72,21 @@ interface CookieDescriptorOptions<T extends TSchema> {
   /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
-interface CookieDescriptor<T extends TSchema> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: CookieDescriptorOptions<T>;
-  schema: T;
+declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescriptorOptions<T>> {
+  protected readonly serverCookiesProvider: ServerCookiesProvider;
+  get name(): string;
   /** Sets the cookie with the given value in the current request's response. */
-  set: (value: Static<T>, options?: {
+  set(value: Static<T>, options?: {
     cookies?: Cookies;
-  }) => void;
+  }): void;
   /** Gets the cookie value from the current request. Returns undefined if not found or invalid. */
-  get: (options?: {
+  get(options?: {
     cookies?: Cookies;
-  }) => Static<T> | undefined;
+  }): Static<T> | undefined;
   /** Deletes the cookie in the current request's response. */
-  del: (options?: {
+  del(options?: {
     cookies?: Cookies;
-  }) => void;
+  }): void;
 }
 interface Cookies {
   req: Record<string, string>;
@@ -67,229 +101,27 @@ interface Cookie {
   sameSite?: "strict" | "lax" | "none";
   domain?: string;
 }
-//#endregion
-//#region src/providers/ServerCookiesProvider.d.ts
-declare const envSchema: TObject<{
-  COOKIE_SECRET: TOptional<TString>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-declare class ServerCookiesProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: Logger;
-  protected readonly env: Static<typeof envSchema>;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  // Crypto constants
-  protected readonly ALGORITHM = "aes-256-gcm";
-  protected readonly IV_LENGTH = 16;
-  protected readonly AUTH_TAG_LENGTH = 16;
-  protected readonly SIGNATURE_LENGTH = 32;
-  protected readonly configure: HookDescriptor<"configure">;
-  protected createApi<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
-  readonly onRequest: HookDescriptor<"server:onRequest">;
-  readonly onSend: HookDescriptor<"server:onSend">;
-  protected getCookiesFromContext(cookies?: Cookies): Cookies;
-  protected getCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, contextCookies?: Cookies): Static<T> | undefined;
-  protected setCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, data: Static<T>, contextCookies?: Cookies): void;
-  protected deleteCookie<T extends TSchema>(name: string, contextCookies?: Cookies): void;
-  // --- Crypto & Parsing ---
-  protected encrypt(text: string): string;
-  protected decrypt(encryptedText: string): string;
-  secretKey(): string;
-  protected sign(data: string): string;
-  protected parseRequestCookies(header: string): Record<string, string>;
-  protected serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
-}
+//# sourceMappingURL=$cookie.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 declare module "alepha/server" {
   interface ServerRequest {
     cookies: Cookies;
   }
 }
 /**
-* Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
-*
-* The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
-* It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
-* for managing user sessions, preferences, and authentication tokens.
-*
-* **Key Features:**
-* - Declarative cookie definition with `$cookie` descriptor
-* - Automatic cookie parsing from requests
-* - Secure cookie configuration (httpOnly, secure, sameSite)
-* - Type-safe cookie values with schema validation
-* - Automatic cookie serialization and deserialization
-* - Integration with server request/response lifecycle
-*
-* **Basic Usage:**
-* ```ts
-* import { Alepha, run, t } from "alepha";
-* import { AlephaServer, $route } from "alepha/server";
-* import { AlephaServerCookies, $cookie } from "alepha/server/cookies";
-*
-* class AuthRoutes {
-*   // Define authentication cookie
-*   authToken = $cookie({
-*     name: "auth_token",
-*     httpOnly: true,
-*     secure: true,
-*     sameSite: "strict",
-*     maxAge: "7d",
-*   });
-*
-*   // Define user preferences cookie
-*   userPrefs = $cookie({
-*     name: "user_prefs",
-*     schema: t.object({
-*       theme: t.union([t.literal("light"), t.literal("dark")]),
-*       language: t.string(),
-*     }),
-*     maxAge: "30d",
-*   });
-*
-*   login = $route({
-*     path: "/login",
-*     method: "POST",
-*     schema: {
-*       body: t.object({
-*         email: t.string(),
-*         password: t.string(),
-*       }),
-*     },
-*     handler: async ({ body, reply }) => {
-*       const user = await authenticateUser(body.email, body.password);
-*       if (!user) {
-*         return new Response("Invalid credentials", { status: 401 });
-*       }
-*
-*       const token = await generateJWT(user.id);
-*
-*       // Set authentication cookie
-*       this.authToken.set(reply, token);
-*
-*       return Response.json({ success: true, user });
-*     },
-*   });
-*
-*   profile = $route({
-*     path: "/profile",
-*     method: "GET",
-*     handler: async ({ cookies }) => {
-*       // Get authentication token from cookie
-*       const token = this.authToken.get(cookies);
-*       if (!token) {
-*         return new Response("Unauthorized", { status: 401 });
-*       }
-*
-*       const user = await validateJWT(token);
-*       const preferences = this.userPrefs.get(cookies) || {
-*         theme: "light",
-*         language: "en",
-*       };
-*
-*       return Response.json({ user, preferences });
-*     },
-*   });
-*
-*   logout = $route({
-*     path: "/logout",
-*     method: "POST",
-*     handler: async ({ reply }) => {
-*       // Clear authentication cookie
-*       this.authToken.clear(reply);
-*       return Response.json({ success: true });
-*     },
-*   });
-* }
-*
-* const alepha = Alepha.create()
-*   .with(AlephaServer)
-*   .with(AlephaServerCookies)
-*   .with(AuthRoutes);
-*
-* run(alepha);
-* ```
-*
-* **Advanced Cookie Management:**
-* ```ts
-* class SessionRoutes {
-*   // Session cookie with custom configuration
-*   sessionId = $cookie({
-*     name: "session_id",
-*     httpOnly: true,
-*     secure: process.env.NODE_ENV === "production",
-*     sameSite: "lax",
-*     path: "/",
-*     maxAge: "2h",
-*     encrypt: true, // Optional encryption
-*   });
-*
-*   // Shopping cart cookie
-*   cart = $cookie({
-*     name: "shopping_cart",
-*     schema: t.object({
-*       items: t.array(t.object({
-*         id: t.string(),
-*         quantity: t.number(),
-*       })),
-*       total: t.number(),
-*     }),
-*     maxAge: "30d",
-*   });
-*
-*   // Tracking consent cookie
-*   consent = $cookie({
-*     name: "tracking_consent",
-*     schema: t.object({
-*       analytics: t.boolean(),
-*       marketing: t.boolean(),
-*       functional: t.boolean(),
-*     }),
-*     maxAge: "1y",
-*   });
-*
-*   updateCart = $route({
-*     path: "/cart",
-*     method: "POST",
-*     schema: {
-*       body: t.object({
-*         productId: t.string(),
-*         quantity: t.number(),
-*       }),
-*     },
-*     handler: async ({ body, cookies, reply }) => {
-*       const currentCart = this.cart.get(cookies) || { items: [], total: 0 };
-*
-*       // Update cart logic
-*       const existingItem = currentCart.items.find(item => item.id === body.productId);
-*       if (existingItem) {
-*         existingItem.quantity = body.quantity;
-*       } else {
-*         currentCart.items.push({ id: body.productId, quantity: body.quantity });
-*       }
-*
-*       // Recalculate total
-*       currentCart.total = await calculateCartTotal(currentCart.items);
-*
-*       // Update cookie
-*       this.cart.set(reply, currentCart);
-*
-*       return Response.json(currentCart);
-*     },
-*   });
-* }
-* ```
-*
-* @see {@link $cookie}
-* @module alepha.server.cookies
-*/
-declare class AlephaServerCookies implements Module {
-  readonly name = "alepha.server.cookies";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
+ *
+ * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
+ * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
+ * for managing user sessions, preferences, and authentication tokens.
+ *
+ * @see {@link $cookie}
+ * @module alepha.server.cookies
+ */
+declare const AlephaServerCookies: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $cookie, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/cors.d.ts

@@ -1,29 +1,31 @@
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
 import { ServerRouterProvider } from "alepha/server";
-import { Alepha, HookDescriptor, Module } from "alepha";
 
 //#region src/providers/ServerCorsProvider.d.ts
 declare class ServerCorsProvider {
   protected readonly serverRouterProvider: ServerRouterProvider;
-  options: CorsOptions;
-  protected readonly onRoute: HookDescriptor<"server:onRoute">;
-  protected readonly onRequest: HookDescriptor<"server:onRequest">;
-  isOriginAllowed(origin: string | undefined, allowed: CorsOptions["origin"]): boolean;
+  options: ServerCorsProviderOptions;
+  protected readonly configure: _alepha_core0$1.HookDescriptor<"configure">;
+  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  isOriginAllowed(origin: string | undefined, allowed: ServerCorsProviderOptions["origin"]): boolean;
 }
-// ---------------------------------------------------------------------------------------------------------------------
-interface CorsOptions {
+interface ServerCorsProviderOptions {
   origin?: string | string[] | ((origin: string | undefined) => boolean);
   methods: string[];
   headers: string[];
   credentials?: boolean;
   maxAge?: number;
 }
+//# sourceMappingURL=ServerCorsProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
-declare class AlephaServerCors implements Module {
-  readonly name = "alepha.server.cors";
-  readonly $services: (alepha: Alepha) => void;
-}
+/**
+ * Plugin for configuring CORS on the Alepha server.
+ */
+declare const AlephaServerCors: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { AlephaServerCors, CorsOptions, ServerCorsProvider };
+export { AlephaServerCors, ServerCorsProvider, ServerCorsProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/server/health.d.ts

@@ -1,39 +1,39 @@
-import { RouteDescriptor } from "alepha/server";
-import { Alepha, TBoolean, TNumber, TObject, TString } from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha } from "alepha";
+import * as _alepha_server0 from "alepha/server";
 import { DateTimeProvider } from "alepha/datetime";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/providers/ServerHealthProvider.d.ts
-
 /**
-* Register `/health` endpoint.
-*
-* - Provides basic health information about the server.
-*/
+ * Register `/health` endpoint.
+ *
+ * - Provides basic health information about the server.
+ */
 declare class ServerHealthProvider {
   protected readonly time: DateTimeProvider;
   protected readonly alepha: Alepha;
-  readonly health: RouteDescriptor<{
-    response: TObject<{
-      message: TString;
-      uptime: TNumber;
-      date: TString;
-      ready: TBoolean;
+  readonly health: _alepha_server0.RouteDescriptor<{
+    response: _sinclair_typebox0.TObject<{
+      message: _sinclair_typebox0.TString;
+      uptime: _sinclair_typebox0.TNumber;
+      date: _sinclair_typebox0.TString;
+      ready: _sinclair_typebox0.TBoolean;
     }>;
   }>;
 }
+//# sourceMappingURL=ServerHealthProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Plugin for Alepha Server that provides health-check endpoints.
-*
-* @see {@link ServerHealthProvider}
-* @module alepha.server.health
-*/
-declare class AlephaServerHealth {
-  readonly name = "alepha.server.health";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * Plugin for Alepha Server that provides health-check endpoints.
+ *
+ * @see {@link ServerHealthProvider}
+ * @module alepha.server.health
+ */
+declare const AlephaServerHealth: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerHealth, ServerHealthProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/helmet.d.ts

@@ -1,4 +1,5 @@
-import { Alepha, HookDescriptor, Module } from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, HookDescriptor } from "alepha";
 
 //#region src/providers/ServerHelmetProvider.d.ts
 type CspDirective = string | string[];
@@ -38,33 +39,31 @@ interface HelmetOptions {
   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.
-*/
+ * 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()`.
-  */
+   * 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
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* 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;
-}
+ * 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 const AlephaServerHelmet: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerHelmet, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
 //# sourceMappingURL=index.d.ts.map