alepha 0.8.1 → 0.9.0

package/scheduler.d.ts

@@ -1,19 +1,54 @@
-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;
 };
 type SchedulerDescriptorOptions = {
   /**
@@ -44,100 +79,29 @@ 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
@@ -147,12 +111,9 @@ interface Scheduler {
  * @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 };
+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,61 +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";
-/**
- *
- */
-declare const $permission: {
-  (options?: PermissionDescriptorOptions): PermissionDescriptor;
-  [KIND]: string;
-};
-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;
-}
-//#endregion
 //#region src/interfaces/UserAccountToken.d.ts
 interface UserAccountToken extends UserAccountInfo {
   /**
@@ -108,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>;
@@ -127,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;
   /**
@@ -211,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>> {}
@@ -221,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;
@@ -235,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.
    *
@@ -275,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.
    *
@@ -299,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.
    *
@@ -395,15 +337,47 @@ 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";
 /**
- *
- * @param options
+ * Create a new realm.
  */
 declare const $realm: {
   (options?: RealmDescriptorOptions): RealmDescriptor;
-  [KIND]: string;
+  [KIND]: typeof RealmDescriptor;
 };
 interface RealmDescriptorOptions {
   /**
@@ -433,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.
    */
@@ -453,15 +429,15 @@ interface RealmDescriptor {
    */
   createToken(subject: string, roles?: string[]): Promise<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]: string;
+  [KIND]: typeof RoleDescriptor;
 };
 interface RoleDescriptorOptions {
   /**
@@ -472,19 +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;
 }
+//# sourceMappingURL=$role.d.ts.map
 //#endregion
 //#region src/descriptors/$serviceAccount.d.ts
 /**
@@ -585,172 +564,12 @@ declare module "alepha" {
  * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
  * integration with various authentication providers and user management systems.
  *
- * **Key Features:**
- * - Declarative realm definition with `$realm` descriptor for user authentication
- * - Role-based access control with `$role` descriptor
- * - Fine-grained permissions with `$permission` descriptor
- * - Service account management with `$serviceAccount` descriptor
- * - JWT token generation and validation
- * - OAuth integration and external provider support
- * - User session management and security hooks
- *
- * **Basic Usage:**
- * ```ts
- * import { Alepha, run, t } from "alepha";
- * import { AlephaSecurity, $realm, $role, $permission } from "alepha/security";
- *
- * // Define user roles
- * const adminRole = $role({
- *   name: "admin",
- *   description: "Administrator with full access",
- * });
- *
- * const userRole = $role({
- *   name: "user",
- *   description: "Regular user with limited access",
- * });
- *
- * // Define permissions
- * const readUsersPermission = $permission({
- *   name: "users:read",
- *   description: "Read user information",
- * });
- *
- * const writeUsersPermission = $permission({
- *   name: "users:write",
- *   description: "Create and update users",
- * });
- *
- * // Define authentication realm
- * class AuthSystem {
- *   userRealm = $realm({
- *     name: "users",
- *     roles: [adminRole, userRole],
- *     permissions: [readUsersPermission, writeUsersPermission],
- *     authenticate: async (token: string) => {
- *       // Validate user token and return user info
- *       const user = await validateUserToken(token);
- *       return {
- *         id: user.id,
- *         email: user.email,
- *         roles: user.roles,
- *         permissions: user.permissions,
- *       };
- *     },
- *   });
- * }
- *
- * const alepha = Alepha.create()
- *   .with(AlephaSecurity)
- *   .with(AuthSystem);
- *
- * run(alepha);
- * ```
- *
- * **OAuth Integration:**
- * ```ts
- * import { $serviceAccount } from "alepha/security";
- *
- * class OAuthSystem {
- *   googleAuth = $realm({
- *     name: "google-oauth",
- *     provider: "oauth",
- *     config: {
- *       clientId: process.env.GOOGLE_CLIENT_ID,
- *       clientSecret: process.env.GOOGLE_CLIENT_SECRET,
- *       redirectUri: "https://myapp.com/auth/callback",
- *       scope: ["email", "profile"],
- *     },
- *     authenticate: async (oauthToken: string) => {
- *       const userInfo = await fetchGoogleUserInfo(oauthToken);
- *       return {
- *         id: userInfo.sub,
- *         email: userInfo.email,
- *         name: userInfo.name,
- *         roles: ["user"],
- *       };
- *     },
- *   });
- *
- *   serviceAccount = $serviceAccount({
- *     name: "api-service",
- *     permissions: ["api:read", "api:write"],
- *     secret: process.env.SERVICE_ACCOUNT_SECRET,
- *   });
- * }
- * ```
- *
- * **Role and Permission Management:**
- * ```ts
- * class PermissionSystem {
- *   // Define hierarchical roles
- *   superAdminRole = $role({
- *     name: "super-admin",
- *     inherits: [adminRole],
- *     permissions: ["*"], // All permissions
- *   });
- *
- *   moderatorRole = $role({
- *     name: "moderator",
- *     inherits: [userRole],
- *     permissions: ["posts:moderate", "comments:moderate"],
- *   });
- *
- *   // Define resource-specific permissions
- *   postPermissions = [
- *     $permission({ name: "posts:create", description: "Create posts" }),
- *     $permission({ name: "posts:edit", description: "Edit posts" }),
- *     $permission({ name: "posts:delete", description: "Delete posts" }),
- *     $permission({ name: "posts:moderate", description: "Moderate posts" }),
- *   ];
- *
- *   // Check permissions in application logic
- *   async checkUserPermission(userId: string, permission: string) {
- *     const user = await this.userRealm.getUser(userId);
- *     return user.permissions.includes(permission);
- *   }
- * }
- * ```
- *
- * **JWT Token Management:**
- * ```ts
- * class TokenSystem {
- *   userTokens = $realm({
- *     name: "jwt-tokens",
- *     jwtConfig: {
- *       secret: process.env.JWT_SECRET,
- *       expiresIn: "24h",
- *       issuer: "myapp.com",
- *       audience: "myapp-users",
- *     },
- *     authenticate: async (jwtToken: string) => {
- *       // JWT validation is handled automatically
- *       // Return user data from token payload
- *       return jwtToken.payload;
- *     },
- *   });
- *
- *   async generateUserToken(user: { id: string; email: string; roles: string[] }) {
- *     return await this.userTokens.generateToken({
- *       sub: user.id,
- *       email: user.email,
- *       roles: user.roles,
- *       iat: Date.now(),
- *     });
- *   }
- * }
- * ```
- *
  * @see {@link $realm}
  * @see {@link $role}
  * @see {@link $permission}
- * @see {@link $serviceAccount}
  * @module alepha.security
  */
-declare class AlephaSecurity {
-  readonly name = "alepha.security";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaSecurity: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion