alepha 0.7.2 → 0.7.4

package/queue.d.ts

@@ -1,83 +1,38 @@
 import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha, Module } from '@alepha/core';
 import { DateTimeProvider } from '@alepha/datetime';
-import { RedisProvider } from '@alepha/redis';
 
-/** Symbol key applied to readonly types */
-declare const ReadonlyKind: unique symbol;
-/** Symbol key applied to optional types */
-declare const OptionalKind: unique symbol;
-/** Symbol key applied to types */
-declare const Hint: unique symbol;
-/** Symbol key applied to types */
-declare const Kind: unique symbol;
-
-interface TUnsafe<T> extends TSchema {
-    [Kind]: string;
-    static: T;
-}
-
-interface NumberOptions extends SchemaOptions {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-}
-interface TNumber extends TSchema, NumberOptions {
-    [Kind]: 'Number';
-    static: number;
-    type: 'number';
-}
-
-interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-interface TKind {
-    [Kind]: string;
-}
-interface TSchema extends TKind, SchemaOptions {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}
-
-declare class QueueProvider {
-    constructor();
+/**
+ * Minimalist Queue interface.
+ *
+ * Will be probably enhanced in the future to support more advanced features. But for now, it's enough!
+ */
+declare abstract class QueueProvider {
     /**
      * Push a message to the queue.
      *
-     * @param queue - The queue name.
-     * @param message - The message to push.
+     * @param queue Name of the queue to push the message to.
+     * @param message String message to be pushed to the queue. Buffer messages are not supported for now.
      */
-    push(_queue: string, _message: string): Promise<void>;
+    abstract push(queue: string, message: string): Promise<void>;
     /**
      * Pop a message from the queue.
      *
-     * @param queue - The queue name.
-     * @returns The message popped.
+     * @param queue Name of the queue to pop the message from.
+     *
+     * @returns The message popped or `undefined` if the queue is empty.
      */
-    pop(_queue: string): Promise<string | undefined>;
+    abstract pop(queue: string): Promise<string | undefined>;
 }
 
 declare const KEY$1 = "QUEUE";
+/**
+ * Queue descriptor.
+ */
+declare const $queue: {
+    <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+    [KIND]: string;
+};
 interface QueueMessageSchema {
     headers?: TSchema$1;
     payload: TSchema$1;
@@ -98,18 +53,15 @@ interface QueueDescriptor<T extends QueueMessageSchema = QueueMessageSchema> {
     provider(): QueueProvider;
     push(...payload: Array<Static<T["payload"]>>): Promise<void>;
 }
+
+declare const KEY = "CONSUMER";
 /**
- * Queue descriptor.
- *
- * @param options - The queue options.
- * @returns The descriptor value.
+ * Consumer descriptor.
  */
-declare const $queue: {
-    <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+declare const $consumer: {
+    <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
     [KIND]: string;
 };
-
-declare const KEY = "CONSUMER";
 interface ConsumerDescriptorOptions<T extends QueueMessageSchema = QueueMessageSchema> {
     queue: QueueDescriptor<T>;
     handler: (message: {
@@ -122,44 +74,66 @@ interface ConsumerDescriptor<T extends QueueMessageSchema = QueueMessageSchema>
     queue(): QueueDescriptor<T>;
     stop(): Promise<void>;
 }
-/**
- * Consumer descriptor.
- *
- * @param options - The consumer options.
- * @returns The descriptor value.
- */
-declare const $consumer: {
-    <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
-    [KIND]: string;
-};
 
 declare class MemoryQueueProvider implements QueueProvider {
-    /**
-     * The in-memory queue list.
-     */
-    protected queueList: Record<string, string[]>;
     protected readonly log: _alepha_core.Logger;
-    /**
-     * Push a message to a queue.
-     * The message is added to the end of the queue.
-     * The queue is created if it does not exist.
-     *
-     * @param queue - The queue to push to.
-     * @param messages The messages to push.
-     */
+    protected queueList: Record<string, string[]>;
     push(queue: string, ...messages: string[]): Promise<void>;
-    /**
-     * Pop a message from a queue.
-     * The message is removed from the queue.
-     * If the queue is empty, this method will return undefined.
-     *
-     * @param queue - The queue to pop from.
-     * @returns The message that was popped from the queue.
-     */
     pop(queue: string): Promise<string | undefined>;
 }
 
-declare const envSchema$1: _alepha_core.TObject<{
+/** Symbol key applied to readonly types */
+declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+declare const Hint: unique symbol;
+/** Symbol key applied to types */
+declare const Kind: unique symbol;
+
+interface NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+
+interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+interface TKind {
+    [Kind]: string;
+}
+interface TSchema extends TKind, SchemaOptions {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+
+declare const envSchema: _alepha_core.TObject<{
     /**
      * The interval in milliseconds to wait before checking for new messages.
      */
@@ -175,7 +149,7 @@ declare const envSchema$1: _alepha_core.TObject<{
     QUEUE_WORKER_CONCURRENCY: TNumber;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static<typeof envSchema$1>> {
+    interface Env extends Partial<Static<typeof envSchema>> {
     }
 }
 interface QueueDescriptorProviderState {
@@ -217,90 +191,63 @@ declare class QueueDescriptorProvider {
     protected processQueueDescriptors(): void;
     /**
      * Process the consumer descriptors.
-     *
-     * @protected
      */
     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>;
     /**
      * Start the workers.
-     *
-     * @param consumers
-     * @protected
+     * This method will create an endless loop that will check for new messages!
      */
     protected startWorkers(consumers: Array<ConsumerDescriptorOptions>): void;
     /**
-     * Wait for the next message.
+     * Wait for the next message, where `n` is the worker number.
      *
-     * @param n
-     * @protected
+     * This method will wait for a certain amount of time, increasing the wait time again if no message is found.
      */
     protected waitForNextMessage(n: number): Promise<void>;
     /**
      * Get the next message.
-     *
-     * @param consumers
-     * @protected
      */
     protected getNextMessage(consumers: Array<ConsumerDescriptorOptions>): Promise<undefined | {
-        message: any;
         consumer: ConsumerDescriptorOptions;
+        message: string;
     }>;
     /**
      * Process a message from a queue.
-     *
-     * @param response
-     * @protected
      */
     protected processMessage(response: {
         message: any;
         consumer: ConsumerDescriptorOptions;
     }): Promise<void>;
     /**
-     * Stop the workers
+     * Stop the workers.
      *
-     * @protected
+     * This method will stop the workers and wait for them to finish processing.
      */
     protected stopWorkers(): Promise<void>;
-    /**
-     * Get the provider for the queue.
-     *
-     * @param options - The queue options.
-     * @protected
-     */
-    protected provider(options: QueueDescriptorOptions<any>): QueueProvider;
-    /**
-     * Push an item to the queue.
-     *
-     * @param queue
-     * @param payloads
-     * @protected
-     */
-    protected push<T extends QueueMessageSchema>(queue: QueueDescriptor<T>, ...payloads: Array<Static<T["payload"]>>): Promise<void>;
-}
-
-declare class RedisQueueProvider implements QueueProvider {
-    protected readonly env: {
-        REDIS_QUEUE_PREFIX: string;
-    };
-    protected readonly redisProvider: RedisProvider;
-    prefix(queue: string): string;
-    push(queue: string, message: string): Promise<void>;
-    pop(queue: string): Promise<string | undefined>;
 }
 
-declare const envSchema: _alepha_core.TObject<{
-    QUEUE_PROVIDER: TUnsafe<"memory" | "redis">;
-}>;
-declare module "alepha/core" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
-}
-declare class QueueModule {
-    protected readonly alepha: Alepha;
-    protected readonly env: {
-        QUEUE_PROVIDER: "memory" | "redis";
-    };
-    constructor();
+/**
+ * Alepha Queue Module
+ *
+ * Generic interface for queueing.
+ * Gives you the ability to create queues and consumers.
+ * This module provides only a memory implementation of the queue provider.
+ *
+ * @see {@link $queue}
+ * @see {@link $consumer}
+ * @module alepha.queue
+ */
+declare class AlephaQueue implements Module {
+    readonly name = "alepha.queue";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $consumer, $queue, type ConsumerDescriptor, type ConsumerDescriptorOptions, MemoryQueueProvider, type QueueDescriptor, type QueueDescriptorOptions, QueueDescriptorProvider, type QueueDescriptorProviderState, type QueueMessageSchema, QueueModule, QueueProvider, RedisQueueProvider };
+export { $consumer, $queue, AlephaQueue, type ConsumerDescriptor, type ConsumerDescriptorOptions, MemoryQueueProvider, type QueueDescriptor, type QueueDescriptorOptions, QueueDescriptorProvider, type QueueDescriptorProviderState, type QueueMessageSchema, QueueProvider };

package/react/auth.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core from '@alepha/core';
-import { Async, KIND, OPTIONS, Alepha } from '@alepha/core';
+import { Async, KIND, OPTIONS, Alepha, Module } from '@alepha/core';
 import { UserAccountToken } from '@alepha/security';
 import * as _alepha_server from '@alepha/server';
 import { HttpVirtualClient, HttpClient } from '@alepha/server';
@@ -300,9 +300,17 @@ declare module "alepha/react" {
         user?: ReactUser;
     }
 }
-declare class ReactAuthModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * Alepha React Authentication Module
+ *
+ * The ReactAuthModule provides authentication services for React applications.
+ *
+ * @see {@link ReactAuthProvider}
+ * @module alepha.react.auth
+ */
+declare class AlephaReactAuth implements Module {
+    readonly name = "alepha.react.auth";
+    readonly $services: (alepha: Alepha) => void;
 }
 
-export { $auth, type AccessToken, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthModule, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };
+export { $auth, type AccessToken, AlephaReactAuth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };

package/react.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static as Static$1, Async, Alepha, Service, TObject as TObject$1 } from '@alepha/core';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static, Async, Alepha, Service, TObject, Module } from '@alepha/core';
 import { ServerRoute, ServerRequest, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler } from '@alepha/server';
 import * as React from 'react';
 import React__default, { PropsWithChildren, ReactNode, FC, ErrorInfo, AnchorHTMLAttributes } from 'react';
@@ -17,10 +17,6 @@ declare const Hint: unique symbol;
 /** Symbol key applied to types */
 declare const Kind: unique symbol;
 
-type TReadonly<T extends TSchema> = T & {
-    [ReadonlyKind]: 'Readonly';
-};
-
 type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
 type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
 interface StringOptions extends SchemaOptions {
@@ -53,49 +49,6 @@ type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
 
-/** Creates a static type from a TypeBox type */
-type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
-    params: Params;
-})['static']> = Result;
-
-type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
-}[keyof T];
-type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
-}[keyof T];
-type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
-}[keyof T];
-type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
-    [K in keyof T]: Static<T[K], P>;
-}>;
-type TPropertyKey = string | number;
-type TProperties = Record<TPropertyKey, TSchema>;
-type TAdditionalProperties = undefined | TSchema | boolean;
-interface ObjectOptions extends SchemaOptions {
-    /** Additional property constraints for this object */
-    additionalProperties?: TAdditionalProperties;
-    /** The minimum number of properties allowed on this object */
-    minProperties?: number;
-    /** The maximum number of properties allowed on this object */
-    maxProperties?: number;
-}
-interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
-    [Kind]: 'Object';
-    static: ObjectStatic<T, this['params']>;
-    additionalProperties?: TAdditionalProperties;
-    type: 'object';
-    properties: T;
-    required?: string[];
-}
-
-type Evaluate<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-
 interface SchemaOptions {
     $schema?: string;
     /** Id for this schema */
@@ -292,8 +245,8 @@ interface Head$1 {
     };
 }
 interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
-    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
+    params: TConfig["params"] extends TSchema$1 ? Static<TConfig["params"]> : Record<string, string>;
+    query: TConfig["query"] extends TSchema$1 ? Static<TConfig["query"]> : Record<string, string>;
 }
 type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
 
@@ -301,7 +254,7 @@ declare const envSchema$1: _alepha_core.TObject<{
     REACT_STRICT_MODE: TBoolean;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    interface Env extends Partial<Static<typeof envSchema$1>> {
     }
 }
 declare class PageDescriptorProvider {
@@ -647,7 +600,7 @@ interface UseQueryParamsHookOptions {
     key?: string;
     push?: boolean;
 }
-declare const useQueryParams: <T extends TObject$1>(schema: T, options?: UseQueryParamsHookOptions) => [Static$1<T>, (data: Static$1<T>) => void];
+declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Static<T>, (data: Static<T>) => void];
 
 declare const useRouter: () => RouterHookApi;
 
@@ -666,14 +619,14 @@ declare const useRouterEvents: (opts?: {
 
 declare const useRouterState: () => RouterState;
 
-declare const envSchema: TObject<{
+declare const envSchema: _alepha_core.TObject<{
     REACT_SERVER_DIST: TString;
     REACT_SERVER_PREFIX: TString;
     REACT_SSR_ENABLED: TOptional<TBoolean>;
     REACT_ROOT_ID: TString;
 }>;
 declare module "alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema>> {
+    interface Env extends Partial<Static<typeof envSchema>> {
     }
     interface State {
         "ReactServerProvider.template"?: string;
@@ -748,9 +701,18 @@ declare module "@alepha/core" {
         };
     }
 }
-declare class ReactModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * Alepha React Module
+ *
+ * Alepha React Module contains a router for client-side navigation and server-side rendering.
+ * Routes can be defined using the `$page` descriptor.
+ *
+ * @see {@link $page}
+ * @module alepha.react
+ */
+declare class AlephaReact implements Module {
+    readonly name = "alepha.react";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $page, type AnchorProps, ClientOnly, type CreateLayersResult, ErrorBoundary, type Head$1 as Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageDescriptorRenderOptions, type PageDescriptorRenderResult, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, RedirectionError, RouterContext, type RouterContextValue, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterRenderResult, type RouterStackItem, type RouterState, type TPropsDefault, type TPropsParentDefault, type TransitionOptions, type UseActiveHook, type UseQueryParamsHookOptions, type VirtualRouter, envSchema, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $page, AlephaReact, type AnchorProps, ClientOnly, type CreateLayersResult, ErrorBoundary, type Head$1 as Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageDescriptorRenderOptions, type PageDescriptorRenderResult, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, type RouterContextValue, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterRenderResult, type RouterStackItem, type RouterState, type TPropsDefault, type TPropsParentDefault, type TransitionOptions, type UseActiveHook, type UseQueryParamsHookOptions, type VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };

package/redis.d.ts

@@ -1,7 +1,6 @@
-import * as _redis_client from '@redis/client';
-import { createClient, SetOptions } from '@redis/client';
 import * as _alepha_core from '@alepha/core';
 import { Static, Alepha } from '@alepha/core';
+import { RedisClientType, createClient, SetOptions } from '@redis/client';
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -89,7 +88,9 @@ declare module "alepha" {
     interface Env extends Partial<Static<typeof envSchema>> {
     }
 }
-type RedisClient = ReturnType<typeof createClient>;
+type RedisClient = RedisClientType<{}, {}, {}, 3, {
+    36: BufferConstructor;
+}>;
 type RedisClientOptions = Parameters<typeof createClient>[0];
 type RedisSetOptions = SetOptions;
 declare class RedisProvider {
@@ -100,7 +101,7 @@ declare class RedisProvider {
         REDIS_PORT: number;
         REDIS_HOST: string;
     };
-    protected readonly client: _redis_client.RedisClientType<_redis_client.RedisModules, _redis_client.RedisFunctions, _redis_client.RedisScripts, _redis_client.RespVersions, _redis_client.TypeMapping>;
+    protected readonly client: RedisClient;
     get publisher(): RedisClient;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
@@ -113,6 +114,11 @@ declare class RedisProvider {
      */
     close(): Promise<void>;
     duplicate(options?: Partial<RedisClientOptions>): RedisClient;
+    get(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer | string, options?: RedisSetOptions): Promise<Buffer>;
+    has(key: string): Promise<boolean>;
+    keys(pattern: string): Promise<string[]>;
+    del(keys: string[]): Promise<void>;
     /**
      * Redis subscriber client factory method.
      */
@@ -123,7 +129,7 @@ declare class RedisSubscriberProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
     protected readonly redisProvider: RedisProvider;
-    protected readonly client: _redis_client.RedisClientType<_redis_client.RedisModules, _redis_client.RedisFunctions, _redis_client.RedisScripts, _redis_client.RespVersions, _redis_client.TypeMapping>;
+    protected readonly client: RedisClient;
     get subscriber(): RedisClient;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;

package/retry.d.ts

@@ -1,5 +1,35 @@
 import { MaybePromise } from '@alepha/core';
 
+/**
+ * `$retry` creates a retry descriptor.
+ *
+ * It will retry the given function up to `max` times with a delay of `delay` milliseconds between attempts.
+ *
+ * @example
+ * ```ts
+ * import { $retry } from "@alepha/core";
+ *
+ * class MyService {
+ * 	fetchData = $retry({
+ * 		max: 5, // maximum number of attempts
+ * 		delay: 1000, // ms
+ * 		when: (error) => error.message.includes("Network Error"),
+ * 		handler: async (url: string) => {
+ * 			const response = await fetch(url);
+ * 			if (!response.ok) {
+ * 				throw new Error(`Failed to fetch: ${response.statusText}`);
+ * 			}
+ * 			return response.json();
+ * 		},
+ * 		onError: (error, attempt, url) => {
+ * 	    // error happened, log it or handle it
+ * 			console.error(`Attempt ${attempt} failed for ${url}:`, error);
+ * 		},
+ * 	});
+ * }
+ * ```
+ */
+declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
 /**
  * Retry Descriptor options.
  */
@@ -34,35 +64,5 @@ interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
     onError?: (error: Error, attempt: number, ...parameters: Parameters<T>) => void;
 }
 type RetryDescriptor<T extends (...args: any[]) => any> = (...parameters: Parameters<T>) => MaybePromise<ReturnType<T>>;
-/**
- * `$retry` creates a retry descriptor.
- *
- * It will retry the given function up to `max` times with a delay of `delay` milliseconds between attempts.
- *
- * @example
- * ```ts
- * import { $retry } from "@alepha/core";
- *
- * class MyService {
- * 	fetchData = $retry({
- * 		max: 5, // maximum number of attempts
- * 		delay: 1000, // ms
- * 		when: (error) => error.message.includes("Network Error"),
- * 		handler: async (url: string) => {
- * 			const response = await fetch(url);
- * 			if (!response.ok) {
- * 				throw new Error(`Failed to fetch: ${response.statusText}`);
- * 			}
- * 			return response.json();
- * 		},
- * 		onError: (error, attempt, url) => {
- * 	    // error happened, log it or handle it
- * 			console.error(`Attempt ${attempt} failed for ${url}:`, error);
- * 		},
- * 	});
- * }
- * ```
- */
-declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
 
 export { $retry, type RetryDescriptor, type RetryDescriptorOptions };