alepha 0.8.0 → 0.9.0

package/scheduler.d.ts

@@ -1,21 +1,55 @@
-import * as _alepha_core9 from "alepha";
+import * as _alepha_core4 from "alepha";
+import * as _alepha_core0$1 from "alepha";
 import * as _alepha_core0 from "alepha";
-import { Alepha, Async, KIND, OPTIONS, Static } from "alepha";
-import * as _alepha_lock8 from "alepha/lock";
-import { DateTime, DateTimeProvider, DurationLike, Interval } from "alepha/datetime";
+import { Alepha, Async, Descriptor, KIND, Static } from "alepha";
+import * as _alepha_lock0 from "alepha/lock";
+import { DateTime, DateTimeProvider, DurationLike } from "alepha/datetime";
 import { Cron } from "cron-schedule";
-import * as dayjs10 from "dayjs";
+import * as dayjs0 from "dayjs";
 
+//#region src/providers/CronProvider.d.ts
+declare class CronProvider {
+  protected readonly dt: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  protected readonly log: _alepha_core4.Logger;
+  protected readonly cronJobs: Array<CronJob>;
+  getCronJobs(): Array<CronJob>;
+  protected readonly start: _alepha_core4.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core4.HookDescriptor<"stop">;
+  protected boot(name: string | CronJob): void;
+  abort(name: string | CronJob): void;
+  /**
+   * Registers a cron job.
+   *
+   * It's automatically done when using the `$scheduler` descriptor but can also be used manually.
+   */
+  createCronJob(name: string, expression: string, handler: (context: {
+    now: DateTime;
+  }) => Promise<void>, start?: boolean): void;
+  protected run(task: CronJob, now?: dayjs0.Dayjs): void;
+}
+interface CronJob {
+  name: string;
+  expression: string;
+  handler: (context: {
+    now: DateTime;
+  }) => Promise<void>;
+  cron: Cron;
+  loop: boolean;
+  running?: boolean;
+  onError?: (error: Error) => void;
+  abort: AbortController;
+}
+//# sourceMappingURL=CronProvider.d.ts.map
+//#endregion
 //#region src/descriptors/$scheduler.d.ts
-declare const KEY = "SCHEDULER";
 /**
  * Scheduler descriptor.
  */
 declare const $scheduler: {
   (options: SchedulerDescriptorOptions): SchedulerDescriptor;
-  [KIND]: string;
+  [KIND]: typeof SchedulerDescriptor;
 };
-declare const isScheduler: (value: any) => value is SchedulerDescriptor;
 type SchedulerDescriptorOptions = {
   /**
    * Function to run on schedule.
@@ -45,117 +79,41 @@ type SchedulerDescriptorOptions = {
    */
   lock?: boolean;
 };
-interface SchedulerDescriptor {
-  [KIND]: typeof KEY;
-  [OPTIONS]: SchedulerDescriptorOptions;
-  (): Promise<void>;
-}
-interface SchedulerHandlerArguments {
-  now: DateTime;
-}
-//#endregion
-//#region src/providers/CronScheduler.d.ts
-interface CronJob {
-  handler: (context: {
-    now: DateTime;
-  }) => Promise<void>;
-  cron: Cron;
-  loop: boolean;
-  running?: boolean;
-  onError?: (error: Error) => void;
-  abort: AbortController;
-}
-declare class CronProvider {
-  protected readonly dt: DateTimeProvider;
-  protected readonly alepha: Alepha;
-  protected readonly log: _alepha_core9.Logger;
-  start(cron: CronJob): void;
-  stop(cron: CronJob): void;
-  create(expression: string, handler: (context: {
-    now: DateTime;
-  }) => Promise<void>): CronJob;
-  run(task: CronJob, now?: dayjs10.Dayjs): void;
-}
-//# sourceMappingURL=CronScheduler.d.ts.map
-//#endregion
-//#region src/providers/SchedulerDescriptorProvider.d.ts
-declare const envSchema: _alepha_core0.TObject<{
-  SCHEDULER_PREFIX: _alepha_core0.TOptional<_alepha_core0.TString>;
+declare const envSchema: _alepha_core0$1.TObject<{
+  SCHEDULER_PREFIX: _alepha_core0$1.TOptional<_alepha_core0$1.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-declare class SchedulerDescriptorProvider {
-  protected readonly log: _alepha_core0.Logger;
+declare class SchedulerDescriptor extends Descriptor<SchedulerDescriptorOptions> {
+  protected readonly log: _alepha_core0$1.Logger;
   protected readonly env: {
     SCHEDULER_PREFIX?: string | undefined;
   };
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly cronProvider: CronProvider;
-  protected readonly schedulers: Scheduler[];
-  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
-  protected readonly start: _alepha_core0.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core0.HookDescriptor<"stop">;
-  /**
-   * Get the schedulers.
-   */
-  getSchedulers(): Scheduler[];
-  /**
-   * Process scheduler descriptors.
-   *
-   * @protected
-   */
-  protected processSchedulerDescriptors(): void;
-  /**
-   * Create a scheduler.
-   *
-   * @param options - The scheduler options.
-   * @param instance - The instance of the scheduler.
-   * @param key - Property key name.
-   * @protected
-   */
-  protected createScheduler(options: SchedulerDescriptorOptions, instance: any, key: string): Scheduler;
-  protected createHandler(name: string, options: SchedulerDescriptorOptions): (args: SchedulerHandlerArguments) => Promise<void>;
-  trigger(name: string): Promise<void>;
-  protected runLock: _alepha_lock8.LockDescriptor<(options: SchedulerDescriptorOptions & {
-    name: string;
-    args: SchedulerHandlerArguments;
-  }) => Promise<void>>;
-  /**
-   * Prefix the scheduler key.
-   */
+  get name(): string;
+  protected onInit(): void;
+  trigger(): Promise<void>;
+  protected schedulerLock: _alepha_lock0.LockDescriptor<(args: SchedulerHandlerArguments) => Promise<void>>;
   protected prefix(key: string): string;
-  /**
-   *
-   * @param options
-   * @protected
-   */
   protected getLockGracePeriod(options: SchedulerDescriptorOptions): number;
 }
-interface Scheduler {
-  name: string;
-  options: SchedulerDescriptorOptions;
-  trigger: (args: SchedulerHandlerArguments) => Promise<void>;
-  cron?: CronJob;
-  interval?: Interval;
+interface SchedulerHandlerArguments {
+  now: DateTime;
 }
 //#endregion
 //#region src/index.d.ts
 /**
- * Alepha Scheduler Module
- *
  * Generic interface for scheduling tasks.
  *
  * @see {@link $scheduler}
  * @module alepha.scheduler
  */
-declare class AlephaScheduler {
-  readonly name = "alepha.scheduler";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaScheduler: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { $scheduler, AlephaScheduler, Scheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerHandlerArguments, isScheduler };
+export { $scheduler, AlephaScheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerHandlerArguments };
 //# sourceMappingURL=index.d.ts.map

package/security.d.ts

@@ -1,10 +1,11 @@
-import * as _alepha_core15 from "alepha";
-import * as _alepha_core16 from "alepha";
-import { Alepha, KIND, OPTIONS, Static } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, Static } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { CryptoKey, FlattenedJWSInput, JSONWebKeySet, JWSHeaderParameters, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyObject } from "jose";
-import * as _sinclair_typebox22 from "@sinclair/typebox";
-import * as _sinclair_typebox1 from "@sinclair/typebox";
+import * as _sinclair_typebox13 from "@sinclair/typebox";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/interfaces/UserAccountInfo.d.ts
 /**
@@ -38,58 +39,6 @@ interface UserAccountInfo {
 }
 //# sourceMappingURL=UserAccountInfo.d.ts.map
 //#endregion
-//#region src/schemas/permissionSchema.d.ts
-declare const permissionSchema: _sinclair_typebox22.TObject<{
-  name: _sinclair_typebox22.TString;
-  group: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
-  description: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
-  method: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
-  path: _sinclair_typebox22.TOptional<_sinclair_typebox22.TString>;
-}>;
-type Permission = Static<typeof permissionSchema>;
-//# sourceMappingURL=permissionSchema.d.ts.map
-//#endregion
-//#region src/descriptors/$permission.d.ts
-declare const KEY$2 = "PERMISSION";
-interface PermissionDescriptorOptions {
-  /**
-   * Name of the permission. Use Property name is not provided.
-   */
-  name?: string;
-  /**
-   * Group of the permission. Use Class name is not provided.
-   */
-  group?: string;
-  /**
-   * Describe the permission.
-   */
-  description?: string;
-  /**
-   * HTTP method of the permission. When available.
-   */
-  method?: string;
-  /**
-   * URL of the permission. When available.
-   */
-  url?: string;
-}
-interface PermissionDescriptor {
-  [KIND]: typeof KEY$2;
-  [OPTIONS]: PermissionDescriptorOptions;
-  /**
-   * Get the permission object.
-   */
-  (): Permission;
-  /**
-   * Check if the user has the permission.
-   */
-  can(user: UserAccountInfo): boolean;
-}
-declare const $permission: {
-  (options?: PermissionDescriptorOptions): PermissionDescriptor;
-  [KIND]: string;
-};
-//#endregion
 //#region src/interfaces/UserAccountToken.d.ts
 interface UserAccountToken extends UserAccountInfo {
   /**
@@ -105,15 +54,26 @@ interface UserAccountToken extends UserAccountInfo {
 }
 //# sourceMappingURL=UserAccountToken.d.ts.map
 //#endregion
+//#region src/schemas/permissionSchema.d.ts
+declare const permissionSchema: _sinclair_typebox13.TObject<{
+  name: _sinclair_typebox13.TString;
+  group: _sinclair_typebox13.TOptional<_sinclair_typebox13.TString>;
+  description: _sinclair_typebox13.TOptional<_sinclair_typebox13.TString>;
+  method: _sinclair_typebox13.TOptional<_sinclair_typebox13.TString>;
+  path: _sinclair_typebox13.TOptional<_sinclair_typebox13.TString>;
+}>;
+type Permission = Static<typeof permissionSchema>;
+//# sourceMappingURL=permissionSchema.d.ts.map
+//#endregion
 //#region src/schemas/roleSchema.d.ts
-declare const roleSchema: _sinclair_typebox1.TObject<{
-  name: _sinclair_typebox1.TString;
-  description: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
-  default: _sinclair_typebox1.TOptional<_sinclair_typebox1.TBoolean>;
-  permissions: _sinclair_typebox1.TArray<_sinclair_typebox1.TObject<{
-    name: _sinclair_typebox1.TString;
-    ownership: _sinclair_typebox1.TOptional<_sinclair_typebox1.TBoolean>;
-    exclude: _sinclair_typebox1.TOptional<_sinclair_typebox1.TArray<_sinclair_typebox1.TString>>;
+declare const roleSchema: _sinclair_typebox0.TObject<{
+  name: _sinclair_typebox0.TString;
+  description: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  default: _sinclair_typebox0.TOptional<_sinclair_typebox0.TBoolean>;
+  permissions: _sinclair_typebox0.TArray<_sinclair_typebox0.TObject<{
+    name: _sinclair_typebox0.TString;
+    ownership: _sinclair_typebox0.TOptional<_sinclair_typebox0.TBoolean>;
+    exclude: _sinclair_typebox0.TOptional<_sinclair_typebox0.TArray<_sinclair_typebox0.TString>>;
   }>>;
 }>;
 type Role = Static<typeof roleSchema>;
@@ -124,7 +84,7 @@ type Role = Static<typeof roleSchema>;
  * Provides utilities for working with JSON Web Tokens (JWT).
  */
 declare class JwtProvider {
-  protected readonly log: _alepha_core15.Logger;
+  protected readonly log: _alepha_core0$1.Logger;
   protected readonly keystore: KeyLoaderHolder[];
   protected readonly dateTimeProvider: DateTimeProvider;
   /**
@@ -208,8 +168,8 @@ interface JwtParseResult {
 //# sourceMappingURL=JwtProvider.d.ts.map
 //#endregion
 //#region src/providers/SecurityProvider.d.ts
-declare const envSchema: _alepha_core16.TObject<{
-  SECURITY_SECRET_KEY: _alepha_core16.TString;
+declare const envSchema: _alepha_core1.TObject<{
+  SECURITY_SECRET_KEY: _alepha_core1.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -218,7 +178,7 @@ declare class SecurityProvider {
   protected readonly UNKNOWN_USER_NAME = "Unknown User";
   protected readonly PERMISSION_REGEXP: RegExp;
   protected readonly PERMISSION_REGEXP_WILDCARD: RegExp;
-  protected readonly log: _alepha_core16.Logger;
+  protected readonly log: _alepha_core1.Logger;
   protected readonly jwt: JwtProvider;
   protected readonly env: {
     SECURITY_SECRET_KEY: string;
@@ -232,33 +192,8 @@ declare class SecurityProvider {
    * The realms configured for the security provider.
    */
   protected readonly realms: Realm[];
-  /**
-   * Create realms.
-   */
-  protected createRealms(): Realm[];
-  protected configure: _alepha_core16.HookDescriptor<"configure">;
-  /**
-   * Processes all $permission descriptors.
-   */
-  protected processPermissionDescriptors(): void;
-  /**
-   * Processes all $realm descriptors.
-   */
-  protected processRealmDescriptors(): void;
-  /**
-   * Processes all $role descriptors.
-   */
-  protected processRoleDescriptors(): void;
-  protected ready: _alepha_core16.HookDescriptor<"ready">;
-  /**
-   * Updates the roles for a realm then synchronizes the user account provider if available.
-   *
-   * Only available when the app is started.
-   *
-   * @param realm - The realm to update the roles for.
-   * @param roles - The roles to update.
-   */
-  updateRealm(realm: string, roles: Role[]): Promise<void>;
+  protected configure: _alepha_core1.HookDescriptor<"configure">;
+  protected ready: _alepha_core1.HookDescriptor<"ready">;
   /**
    * Adds a role to one or more realms.
    *
@@ -272,6 +207,16 @@ declare class SecurityProvider {
    * @param raw - The permission to add.
    */
   createPermission(raw: Permission | string): Permission;
+  createRealm(realm: Realm): void;
+  /**
+   * Updates the roles for a realm then synchronizes the user account provider if available.
+   *
+   * Only available when the app is started.
+   *
+   * @param realm - The realm to update the roles for.
+   * @param roles - The roles to update.
+   */
+  updateRealm(realm: string, roles: Role[]): Promise<void>;
   /**
    * Creates a user account from the provided payload.
    *
@@ -296,7 +241,7 @@ declare class SecurityProvider {
    * @param headerOrToken
    * @param permissionLike
    */
-  createUserFromToken(headerOrToken?: string, permissionLike?: Permission | string): Promise<UserAccountToken>;
+  createUserFromToken(headerOrToken?: string, permission?: Permission | string): Promise<UserAccountToken>;
   /**
    * Checks if a user has a specific role.
    *
@@ -392,8 +337,48 @@ interface RealmConfig {
   };
 }
 //#endregion
+//#region src/descriptors/$permission.d.ts
+/**
+ * Create a new permission.
+ */
+declare const $permission: {
+  (options?: PermissionDescriptorOptions): PermissionDescriptor;
+  [KIND]: typeof PermissionDescriptor;
+};
+interface PermissionDescriptorOptions {
+  /**
+   * Name of the permission. Use Property name is not provided.
+   */
+  name?: string;
+  /**
+   * Group of the permission. Use Class name is not provided.
+   */
+  group?: string;
+  /**
+   * Describe the permission.
+   */
+  description?: string;
+}
+declare class PermissionDescriptor extends Descriptor<PermissionDescriptorOptions> {
+  protected readonly securityProvider: SecurityProvider;
+  get name(): string;
+  get group(): string;
+  protected onInit(): void;
+  /**
+   * Check if the user has the permission.
+   */
+  can(user: UserAccountInfo): boolean;
+}
+//# sourceMappingURL=$permission.d.ts.map
+//#endregion
 //#region src/descriptors/$realm.d.ts
-declare const KEY$1 = "REALM";
+/**
+ * Create a new realm.
+ */
+declare const $realm: {
+  (options?: RealmDescriptorOptions): RealmDescriptor;
+  [KIND]: typeof RealmDescriptor;
+};
 interface RealmDescriptorOptions {
   /**
    * Define the realm name.
@@ -422,9 +407,11 @@ interface RealmDescriptorOptions {
    */
   userAccountProvider?: SecurityUserAccountProvider | (() => SecurityUserAccountProvider);
 }
-interface RealmDescriptor {
-  [KIND]: typeof KEY$1;
-  [OPTIONS]: RealmDescriptorOptions;
+declare class RealmDescriptor extends Descriptor<RealmDescriptorOptions> {
+  protected readonly securityProvider: SecurityProvider;
+  protected readonly jwt: JwtProvider;
+  get name(): string;
+  protected onInit(): void;
   /**
    * Get all roles in the realm.
    */
@@ -442,13 +429,16 @@ interface RealmDescriptor {
    */
   createToken(subject: string, roles?: string[]): Promise<string>;
 }
-declare const $realm: {
-  (options?: RealmDescriptorOptions): RealmDescriptor;
-  [KIND]: string;
-};
+//# sourceMappingURL=$realm.d.ts.map
 //#endregion
 //#region src/descriptors/$role.d.ts
-declare const KEY = "ROLE";
+/**
+ * Create a new role.
+ */
+declare const $role: {
+  (options?: RoleDescriptorOptions): RoleDescriptor;
+  [KIND]: typeof RoleDescriptor;
+};
 interface RoleDescriptorOptions {
   /**
    * Name of the role.
@@ -458,23 +448,22 @@ interface RoleDescriptorOptions {
    * Describe the role.
    */
   description?: string;
+  realm?: string | RealmDescriptor;
   permissions?: Array<string | {
     name: string;
     ownership?: boolean;
   }>;
 }
-interface RoleDescriptor {
-  [KIND]: typeof KEY;
-  [OPTIONS]: RoleDescriptorOptions;
+declare class RoleDescriptor extends Descriptor<RoleDescriptorOptions> {
+  protected readonly securityProvider: SecurityProvider;
+  get name(): string;
+  protected onInit(): void;
   /**
-   * Get the role object.
+   * Get the realm of the role.
    */
-  (): Role;
+  get realm(): string | RealmDescriptor | undefined;
 }
-declare const $role: {
-  (options?: RoleDescriptorOptions): RoleDescriptor;
-  [KIND]: string;
-};
+//# sourceMappingURL=$role.d.ts.map
 //#endregion
 //#region src/descriptors/$serviceAccount.d.ts
 /**
@@ -568,10 +557,19 @@ declare module "alepha" {
     };
   }
 }
-declare class AlephaSecurity {
-  readonly name = "alepha.security";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+/**
+ * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
+ *
+ * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
+ * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
+ * integration with various authentication providers and user management systems.
+ *
+ * @see {@link $realm}
+ * @see {@link $role}
+ * @see {@link $permission}
+ * @module alepha.security
+ */
+declare const AlephaSecurity: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion

package/server/cache.d.ts

@@ -1,54 +1,48 @@
-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
 /**
- * # Alepha Server Cache Module
- *
- * @description
  * Plugin for Alepha Server that provides server-side caching capabilities.
  * It uses the Alepha Cache module to cache responses from server actions ($action).
  * It also provides a ETag-based cache invalidation mechanism.
@@ -76,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