alepha 0.8.1 → 0.9.1

package/queue/redis.d.ts

@@ -1,10 +1,12 @@
+import * as _alepha_core0 from "alepha";
+import { Static } from "alepha";
 import { QueueProvider } from "alepha/queue";
-import { Alepha, Module, Static, TObject, TString } from "alepha";
 import { RedisProvider } from "alepha/redis";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/providers/RedisQueueProvider.d.ts
-declare const envSchema: TObject<{
-  REDIS_QUEUE_PREFIX: TString;
+declare const envSchema: _sinclair_typebox0.TObject<{
+  REDIS_QUEUE_PREFIX: _sinclair_typebox0.TString;
 }>;
 declare class RedisQueueProvider implements QueueProvider {
   protected readonly env: Static<typeof envSchema>;
@@ -15,17 +17,15 @@ declare class RedisQueueProvider implements QueueProvider {
 }
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Plugin for Alepha Queue that provides Redis queue capabilities.
-*
-* @see {@link RedisQueueProvider}
-* @module alepha.queue.redis
-*/
-declare class AlephaQueueRedis implements Module {
-  readonly name = "alepha.queue.redis";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+ * Plugin for Alepha Queue that provides Redis queue capabilities.
+ *
+ * @see {@link RedisQueueProvider}
+ * @module alepha.queue.redis
+ */
+declare const AlephaQueueRedis: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaQueueRedis, RedisQueueProvider };
 //# sourceMappingURL=index.d.ts.map

package/queue.d.ts

@@ -1,6 +1,8 @@
-import * as _alepha_core0 from "alepha";
 import * as _alepha_core1 from "alepha";
-import { Alepha, KIND, Module, OPTIONS, Static, TSchema } from "alepha";
+import * as _alepha_core2 from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, Service, Static, TSchema } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 
 //#region src/providers/QueueProvider.d.ts
@@ -28,96 +30,36 @@ declare abstract class QueueProvider {
 }
 //# sourceMappingURL=QueueProvider.d.ts.map
 //#endregion
-//#region src/descriptors/$queue.d.ts
-declare const KEY$1 = "QUEUE";
-/**
- * Create a new queue.
- */
-declare const $queue: {
-  <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
-  [KIND]: string;
-};
-interface QueueMessageSchema {
-  headers?: TSchema;
-  payload: TSchema;
-}
-interface QueueDescriptorOptions<T extends QueueMessageSchema> {
-  name?: string;
-  description?: string;
-  provider?: "memory" | (() => QueueProvider);
-  schema: T;
-  handler?: (message: {
-    payload: Static<T["payload"]>;
-  }) => Promise<void>;
-}
-interface QueueDescriptor<T extends QueueMessageSchema = QueueMessageSchema> {
-  [KIND]: typeof KEY$1;
-  [OPTIONS]: QueueDescriptorOptions<T>;
-  name(): string;
-  provider(): QueueProvider;
-  push(...payload: Array<Static<T["payload"]>>): Promise<void>;
-}
-//#endregion
-//#region src/descriptors/$consumer.d.ts
-declare const KEY = "CONSUMER";
-/**
- * Consumer descriptor.
- */
-declare const $consumer: {
-  <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
-  [KIND]: string;
-};
-interface ConsumerDescriptorOptions<T extends QueueMessageSchema = QueueMessageSchema> {
-  queue: QueueDescriptor<T>;
-  handler: (message: {
-    payload: Static<T["payload"]>;
-  }) => Promise<void>;
-}
-interface ConsumerDescriptor<T extends QueueMessageSchema = QueueMessageSchema> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: ConsumerDescriptorOptions<T>;
-  queue(): QueueDescriptor<T>;
-  stop(): Promise<void>;
-}
-//#endregion
 //#region src/providers/MemoryQueueProvider.d.ts
 declare class MemoryQueueProvider implements QueueProvider {
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: _alepha_core1.Logger;
   protected queueList: Record<string, string[]>;
   push(queue: string, ...messages: string[]): Promise<void>;
   pop(queue: string): Promise<string | undefined>;
 }
 //# sourceMappingURL=MemoryQueueProvider.d.ts.map
 //#endregion
-//#region src/providers/QueueDescriptorProvider.d.ts
-declare const envSchema: _alepha_core1.TObject<{
+//#region src/providers/WorkerProvider.d.ts
+declare const envSchema: _alepha_core2.TObject<{
   /**
    * The interval in milliseconds to wait before checking for new messages.
    */
-  QUEUE_WORKER_INTERVAL: _alepha_core1.TNumber;
+  QUEUE_WORKER_INTERVAL: _alepha_core2.TNumber;
   /**
    * The maximum interval in milliseconds to wait before checking for new messages.
    */
-  QUEUE_WORKER_MAX_INTERVAL: _alepha_core1.TNumber;
+  QUEUE_WORKER_MAX_INTERVAL: _alepha_core2.TNumber;
   /**
    * The number of workers to run concurrently. Defaults to 1.
    * Useful only if you are doing a lot of I/O.
    */
-  QUEUE_WORKER_CONCURRENCY: _alepha_core1.TNumber;
+  QUEUE_WORKER_CONCURRENCY: _alepha_core2.TNumber;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-interface QueueDescriptorProviderState {
-  queues: Array<QueueDescriptor>;
-  consumers: Array<ConsumerDescriptorOptions>;
-  workerPromises: Array<Promise<void>>;
-  isWorkersRunning: boolean;
-  abortController: AbortController;
-  workerIntervals: Record<number, number>;
-}
-declare class QueueDescriptorProvider {
-  protected readonly log: _alepha_core1.Logger;
+declare class WorkerProvider {
+  protected readonly log: _alepha_core2.Logger;
   protected readonly env: {
     QUEUE_WORKER_INTERVAL: number;
     QUEUE_WORKER_MAX_INTERVAL: number;
@@ -125,43 +67,19 @@ declare class QueueDescriptorProvider {
   };
   protected readonly alepha: Alepha;
   protected readonly queueProvider: QueueProvider;
-  protected readonly memoryQueueProvider: MemoryQueueProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly state: QueueDescriptorProviderState;
-  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
-  protected readonly start: _alepha_core1.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
-  getQueues(): QueueDescriptor<QueueMessageSchema>[];
-  getConsumers(): ConsumerDescriptorOptions<QueueMessageSchema>[];
-  /**
-   * Process the descriptors.
-   *
-   * @protected
-   */
-  protected processDescriptors(): void;
-  /**
-   * Process the queue descriptors.
-   *
-   * @protected
-   */
-  protected processQueueDescriptors(): void;
-  /**
-   * Process the consumer descriptors.
-   */
-  protected processConsumerDescriptors(): void;
-  /**
-   * Get the provider for the queue.
-   */
-  protected provider(options: QueueDescriptorOptions<any>): QueueProvider;
-  /**
-   * Push an item to the queue.
-   */
-  protected push<T extends QueueMessageSchema>(queue: QueueDescriptor<T>, ...payloads: Array<Static<T["payload"]>>): Promise<void>;
+  protected workerPromises: Array<Promise<void>>;
+  protected isWorkersRunning: boolean;
+  protected abortController: AbortController;
+  protected workerIntervals: Record<number, number>;
+  protected consumers: Array<Consumer>;
+  protected readonly start: _alepha_core2.HookDescriptor<"start">;
   /**
    * Start the workers.
    * This method will create an endless loop that will check for new messages!
    */
-  protected startWorkers(consumers: Array<ConsumerDescriptorOptions>): void;
+  protected startWorkers(): void;
+  protected readonly stop: _alepha_core2.HookDescriptor<"stop">;
   /**
    * Wait for the next message, where `n` is the worker number.
    *
@@ -171,16 +89,13 @@ declare class QueueDescriptorProvider {
   /**
    * Get the next message.
    */
-  protected getNextMessage(consumers: Array<ConsumerDescriptorOptions>): Promise<undefined | {
-    consumer: ConsumerDescriptorOptions;
-    message: string;
-  }>;
+  protected getNextMessage(): Promise<undefined | NextMessage>;
   /**
    * Process a message from a queue.
    */
   protected processMessage(response: {
     message: any;
-    consumer: ConsumerDescriptorOptions;
+    consumer: Consumer;
   }): Promise<void>;
   /**
    * Stop the workers.
@@ -188,7 +103,67 @@ declare class QueueDescriptorProvider {
    * This method will stop the workers and wait for them to finish processing.
    */
   protected stopWorkers(): Promise<void>;
+  /**
+   * Force the workers to get back to work. zug zug!
+   */
+  wakeUp(): void;
+}
+interface Consumer<T extends TSchema = TSchema> {
+  queue: QueueDescriptor<T>;
+  handler: (message: QueueMessage<T>) => Promise<void>;
+}
+interface NextMessage {
+  consumer: Consumer;
+  message: string;
+}
+//#endregion
+//#region src/descriptors/$queue.d.ts
+/**
+ * Create a new queue.
+ */
+declare const $queue: {
+  <T extends TSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+  [KIND]: typeof QueueDescriptor;
+};
+interface QueueDescriptorOptions<T extends TSchema> {
+  name?: string;
+  description?: string;
+  provider?: "memory" | Service<QueueProvider>;
+  schema: T;
+  handler?: (message: QueueMessage<T>) => Promise<void>;
+}
+declare class QueueDescriptor<T extends TSchema> extends Descriptor<QueueDescriptorOptions<T>> {
+  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly workerProvider: WorkerProvider;
+  readonly provider: QueueProvider | MemoryQueueProvider;
+  push(...payloads: Array<Static<T>>): Promise<void>;
+  get name(): string;
+  protected $provider(): QueueProvider | MemoryQueueProvider;
+}
+interface QueueMessageSchema {
+  payload: TSchema;
+}
+interface QueueMessage<T extends TSchema> {
+  payload: Static<T>;
 }
+//# sourceMappingURL=$queue.d.ts.map
+//#endregion
+//#region src/descriptors/$consumer.d.ts
+/**
+ * Consumer descriptor.
+ */
+declare const $consumer: {
+  <T extends TSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
+  [KIND]: typeof ConsumerDescriptor;
+};
+interface ConsumerDescriptorOptions<T extends TSchema> {
+  queue: QueueDescriptor<T>;
+  handler: (message: {
+    payload: Static<T["payload"]>;
+  }) => Promise<void>;
+}
+declare class ConsumerDescriptor<T extends TSchema> extends Descriptor<ConsumerDescriptorOptions<T>> {}
+//# sourceMappingURL=$consumer.d.ts.map
 //#endregion
 //#region src/index.d.ts
 /**
@@ -198,102 +173,13 @@ declare class QueueDescriptorProvider {
  * on class properties. It supports schema validation, automatic retries, and multiple queue backends for
  * building scalable, decoupled applications with robust error handling.
  *
- * **Key Features:**
- * - Declarative queue definition with `$queue` descriptor
- * - Schema validation for message payloads and headers
- * - Built-in message handlers with automatic processing
- * - Multiple queue backends (memory, Redis, etc.)
- * - Type-safe message publishing and consumption
- * - Automatic retry mechanisms and error handling
- *
- * **Basic Usage:**
- * ```ts
- * import { Alepha, run, t } from "alepha";
- * import { AlephaQueue, $queue } from "alepha/queue";
- *
- * class EmailService {
- *   sendEmail = $queue({
- *     name: "emails",
- *     schema: {
- *       payload: t.object({
- *         to: t.string(),
- *         subject: t.string(),
- *         body: t.string(),
- *       }),
- *     },
- *     handler: async ({ payload }) => {
- *       // Process the email
- *       await sendEmailViaProvider(payload.to, payload.subject, payload.body);
- *       console.log(`Email sent to ${payload.to}`);
- *     },
- *   });
- * }
- *
- * const alepha = Alepha.create()
- *   .with(AlephaQueue)
- *   .with(EmailService);
- *
- * run(alepha);
- * ```
- *
- * **Queue Operations:**
- * ```ts
- * class NotificationService {
- *   notifications = $queue({
- *     name: "notifications",
- *     provider: "memory",
- *     schema: {
- *       payload: t.object({
- *         userId: t.string(),
- *         message: t.string(),
- *         type: t.union([t.literal("info"), t.literal("warning"), t.literal("error")]),
- *       }),
- *     },
- *     handler: async ({ payload }) => {
- *       await sendNotification(payload.userId, payload.message, payload.type);
- *     },
- *   });
- *
- *   async notifyUser(userId: string, message: string, type: "info" | "warning" | "error") {
- *     // Push message to queue
- *     await this.notifications.push({ userId, message, type });
- *   }
- * }
- * ```
- *
- * **Batch Processing:**
- * ```ts
- * class BatchProcessor {
- *   processTasks = $queue({
- *     name: "batch-tasks",
- *     schema: {
- *       payload: t.object({
- *         taskId: t.string(),
- *         data: t.any(),
- *       }),
- *     },
- *     handler: async ({ payload }) => {
- *       await processTask(payload.taskId, payload.data);
- *     },
- *   });
- *
- *   async submitBatch(tasks: Array<{ taskId: string; data: any }>) {
- *     // Push multiple messages at once
- *     await this.processTasks.push(...tasks);
- *   }
- * }
- * ```
- *
  * @see {@link $queue}
  * @see {@link $consumer}
  * @module alepha.queue
  */
-declare class AlephaQueue implements Module {
-  readonly name = "alepha.queue";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaQueue: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { $consumer, $queue, AlephaQueue, ConsumerDescriptor, ConsumerDescriptorOptions, MemoryQueueProvider, QueueDescriptor, QueueDescriptorOptions, QueueDescriptorProvider, QueueDescriptorProviderState, QueueMessageSchema, QueueProvider };
+export { $consumer, $queue, AlephaQueue, ConsumerDescriptor, ConsumerDescriptorOptions, MemoryQueueProvider, QueueDescriptor, QueueDescriptorOptions, QueueMessage, QueueMessageSchema, QueueProvider };
 //# sourceMappingURL=index.d.ts.map

package/react/auth.d.ts

@@ -1,25 +1,21 @@
-import * as _alepha_core1 from "alepha";
-import * as _alepha_core52 from "alepha";
-import { Alepha, Async, KIND, Module, OPTIONS } from "alepha";
-import * as _alepha_server_cookies7 from "alepha/server/cookies";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core4 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Async, Descriptor, KIND } from "alepha";
+import * as _alepha_server_cookies0 from "alepha/server/cookies";
 import { Cookies, ServerCookiesProvider } from "alepha/server/cookies";
-import * as _alepha_server41 from "alepha/server";
+import * as _alepha_server0 from "alepha/server";
 import { HttpClient } from "alepha/server";
 import { Configuration } from "openid-client";
 import { HttpVirtualClient } from "alepha/server/links";
 import { UserAccountToken } from "alepha/security";
-import * as _sinclair_typebox2 from "@sinclair/typebox";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/descriptors/$auth.d.ts
-declare const KEY = "AUTH";
-/**
- *
- */
 declare const $auth: {
   (options: AuthDescriptorOptions): AuthDescriptor;
-  [KIND]: string;
+  [KIND]: typeof AuthDescriptor;
 };
-type AccessToken = string;
 interface AuthDescriptorOptions {
   name?: string;
   fallback?: () => Async<AccessToken>;
@@ -32,59 +28,60 @@ interface AuthDescriptorOptions {
     logoutUri?: string;
   };
 }
-interface AuthDescriptor {
-  [KIND]: typeof KEY;
-  [OPTIONS]: AuthDescriptorOptions;
-  jwks: () => string;
+declare class AuthDescriptor extends Descriptor<AuthDescriptorOptions> {
+  get name(): string;
+  jwks(): string;
 }
+type AccessToken = string;
+//# sourceMappingURL=$auth.d.ts.map
 //#endregion
 //#region src/providers/ReactAuthProvider.d.ts
 declare class ReactAuthProvider {
-  protected readonly log: _alepha_core1.Logger;
+  protected readonly log: _alepha_core0$1.Logger;
   protected readonly alepha: Alepha;
   protected readonly serverCookiesProvider: ServerCookiesProvider;
   protected authProviders: AuthProvider[];
-  protected readonly authorizationCode: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
-    codeVerifier: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    redirectUri: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  protected readonly authorizationCode: _alepha_server_cookies0.CookieDescriptor<_sinclair_typebox0.TObject<{
+    codeVerifier: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    redirectUri: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
   }>>;
-  readonly tokens: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
-    provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    access_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    expires_in: _sinclair_typebox2.TOptional<_sinclair_typebox2.TNumber>;
-    refresh_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    id_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    scope: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    issued_at: _sinclair_typebox2.TOptional<_sinclair_typebox2.TNumber>;
+  readonly tokens: _alepha_server_cookies0.CookieDescriptor<_sinclair_typebox0.TObject<{
+    provider: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    access_token: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    expires_in: _sinclair_typebox0.TOptional<_sinclair_typebox0.TNumber>;
+    refresh_token: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    id_token: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    scope: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    issued_at: _sinclair_typebox0.TOptional<_sinclair_typebox0.TNumber>;
   }>>;
-  readonly user: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
-    id: _sinclair_typebox2.TString;
-    name: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    email: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-    picture: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  readonly user: _alepha_server_cookies0.CookieDescriptor<_sinclair_typebox0.TObject<{
+    id: _sinclair_typebox0.TString;
+    name: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    email: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    picture: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
   }>>;
-  readonly onRender: _alepha_core1.HookDescriptor<"react:server:render:begin">;
-  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
+  readonly onRender: _alepha_core0$1.HookDescriptor<"react:server:render:begin">;
+  protected readonly configure: _alepha_core0$1.HookDescriptor<"configure">;
   protected getAccessTokenFromCookies(tokens: SessionTokens): Promise<string | undefined>;
   /**
    * Configure Fastify to forward Session Access Token to Header Authorization.
    */
-  protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
   /**
    *
    * @param cookies
    * @protected
    */
   protected refresh(cookies: Cookies): Promise<SessionTokens | undefined>;
-  readonly login: _alepha_server41.RouteDescriptor<{
-    query: _sinclair_typebox2.TObject<{
-      redirect: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-      provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  readonly login: _alepha_server0.RouteDescriptor<{
+    query: _sinclair_typebox0.TObject<{
+      redirect: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+      provider: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
     }>;
   }>;
-  readonly callback: _alepha_server41.RouteDescriptor<{
-    query: _sinclair_typebox2.TObject<{
-      provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  readonly callback: _alepha_server0.RouteDescriptor<{
+    query: _sinclair_typebox0.TObject<{
+      provider: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
     }>;
   }>;
   /**
@@ -98,10 +95,10 @@ declare class ReactAuthProvider {
     email: any;
     picture: any;
   } | undefined;
-  readonly logout: _alepha_server41.RouteDescriptor<{
-    query: _sinclair_typebox2.TObject<{
-      redirect: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
-      provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  readonly logout: _alepha_server0.RouteDescriptor<{
+    query: _sinclair_typebox0.TObject<{
+      redirect: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+      provider: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
     }>;
   }>;
   /**
@@ -162,7 +159,7 @@ interface AuthHook {
 //#endregion
 //#region src/services/ReactAuth.d.ts
 declare class ReactAuth {
-  protected readonly log: _alepha_core52.Logger;
+  protected readonly log: _alepha_core4.Logger;
   protected readonly alepha: Alepha;
   protected readonly client: HttpClient;
   static path: {
@@ -170,7 +167,7 @@ declare class ReactAuth {
     callback: string;
     logout: string;
   };
-  readonly onRender: _alepha_core52.HookDescriptor<"react:transition:begin">;
+  readonly onRender: _alepha_core4.HookDescriptor<"react:transition:begin">;
   get user(): UserAccountToken | undefined;
   protected getUserFromCookies(): UserAccountToken | undefined;
   login(): void;
@@ -193,10 +190,7 @@ declare module "alepha/react" {
  * @see {@link ReactAuthProvider}
  * @module alepha.react.auth
  */
-declare class AlephaReactAuth implements Module {
-  readonly name = "alepha.react.auth";
-  readonly $services: (alepha: Alepha) => void;
-}
+declare const AlephaReactAuth: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion

package/react/head.d.ts

@@ -1,6 +1,6 @@
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
 import { PageConfigSchema, PageReactContext, PageRoute, RouterState, TPropsDefault, TPropsParentDefault } from "alepha/react";
-import * as _alepha_core1 from "alepha";
-import { Alepha, Module } from "alepha";
 
 //#region src/interfaces/Head.d.ts
 interface Head extends SimpleHead {
@@ -58,7 +58,7 @@ declare class HeadProvider {
 //#region src/providers/ServerHeadProvider.d.ts
 declare class ServerHeadProvider {
   protected readonly headProvider: HeadProvider;
-  protected readonly onServerRenderEnd: _alepha_core1.HookDescriptor<"react:server:render:end">;
+  protected readonly onServerRenderEnd: _alepha_core0$1.HookDescriptor<"react:server:render:end">;
   renderHead(template: string, head: SimpleHead): string;
   protected mergeAttributes(existing: string, attrs: Record<string, string>): string;
   protected parseAttributes(attrStr: string): Record<string, string>;
@@ -81,10 +81,7 @@ declare module "alepha/react" {
  * @see {@link ServerHeadProvider}
  * @module alepha.react.head
  */
-declare class AlephaReactHead implements Module {
-  readonly name = "alepha.react.head";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaReactHead: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion