alepha 0.10.7 → 0.11.0

package/retry.d.ts

@@ -11,11 +11,11 @@ declare const $retry: {
   <T extends (...args: any[]) => any>(options: RetryDescriptorOptions<T>): RetryDescriptorFn<T>;
   [KIND]: typeof RetryDescriptor;
 };
-interface RetryDescriptorOptions<T$1 extends (...args: any[]) => any> {
+interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
   /**
    * The function to retry.
    */
-  handler: T$1;
+  handler: T;
   /**
    * The maximum number of attempts.
    *
@@ -45,20 +45,20 @@ interface RetryDescriptorOptions<T$1 extends (...args: any[]) => any> {
    * A custom callback for when a retry attempt fails.
    * This is called before the delay.
    */
-  onError?: (error: Error, attempt: number, ...args: Parameters<T$1>) => void;
+  onError?: (error: Error, attempt: number, ...args: Parameters<T>) => void;
   /**
    * An AbortSignal to allow for external cancellation of the retry loop.
    */
   signal?: AbortSignal;
 }
-declare class RetryDescriptor<T$1 extends (...args: any[]) => any> extends Descriptor<RetryDescriptorOptions<T$1>> {
+declare class RetryDescriptor<T extends (...args: any[]) => any> extends Descriptor<RetryDescriptorOptions<T>> {
   protected readonly dateTimeProvider: DateTimeProvider;
   protected appAbortController: AbortController;
-  constructor(args: DescriptorArgs<RetryDescriptorOptions<T$1>>);
-  run(...args: Parameters<T$1>): Promise<ReturnType<T$1>>;
+  constructor(args: DescriptorArgs<RetryDescriptorOptions<T>>);
+  run(...args: Parameters<T>): Promise<ReturnType<T>>;
 }
-interface RetryDescriptorFn<T$1 extends (...args: any[]) => any> extends RetryDescriptor<T$1> {
-  (...args: Parameters<T$1>): Promise<ReturnType<T$1>>;
+interface RetryDescriptorFn<T extends (...args: any[]) => any> extends RetryDescriptor<T> {
+  (...args: Parameters<T>): Promise<ReturnType<T>>;
 }
 interface RetryBackoffOptions {
   /**

package/scheduler.d.ts

@@ -3,8 +3,8 @@ import { Alepha, Async, Descriptor, KIND, Static } from "alepha";
 import * as _alepha_lock0 from "alepha/lock";
 import { DateTime, DateTimeProvider, DurationLike } from "alepha/datetime";
 import * as _alepha_logger0 from "alepha/logger";
-import { Cron } from "cron-schedule";
 import * as dayjs0 from "dayjs";
+import { Cron } from "cron-schedule";
 
 //#region src/constants/CRON.d.ts
 declare const CRON: {

package/security.d.ts

@@ -1,6 +1,6 @@
 import * as _alepha_core1 from "alepha";
 import { Alepha, Descriptor, KIND, Static } from "alepha";
-import * as _alepha_logger0 from "alepha/logger";
+import * as _alepha_logger1 from "alepha/logger";
 import { DateTimeProvider, Duration, DurationLike } from "alepha/datetime";
 import { CryptoKey, FlattenedJWSInput, JSONWebKeySet, JWSHeaderParameters, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyObject } from "jose";
 import * as typebox0 from "typebox";
@@ -68,7 +68,7 @@ type Role = Static<typeof roleSchema>;
  * Provides utilities for working with JSON Web Tokens (JWT).
  */
 declare class JwtProvider {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly keystore: KeyLoaderHolder[];
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly encoder: TextEncoder;
@@ -140,7 +140,7 @@ declare class SecurityProvider {
   protected readonly UNKNOWN_USER_NAME = "Anonymous User";
   protected readonly PERMISSION_REGEXP: RegExp;
   protected readonly PERMISSION_REGEXP_WILDCARD: RegExp;
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly jwt: JwtProvider;
   protected readonly env: {
     APP_SECRET: string;
@@ -399,7 +399,7 @@ declare class RealmDescriptor extends Descriptor<RealmDescriptorOptions> {
   protected readonly securityProvider: SecurityProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly jwt: JwtProvider;
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   get name(): string;
   get accessTokenExpiration(): Duration;
   get refreshTokenExpiration(): Duration;

package/server/cookies.d.ts

@@ -45,9 +45,9 @@ declare const $cookie: {
   <T extends TSchema>(options: CookieDescriptorOptions<T>): AbstractCookieDescriptor<T>;
   [KIND]: typeof CookieDescriptor;
 };
-interface CookieDescriptorOptions<T$1 extends TSchema> {
+interface CookieDescriptorOptions<T extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
-  schema: T$1;
+  schema: T;
   /** The name of the cookie. */
   name?: string;
   /** The cookie's path. Defaults to "/". */
@@ -69,28 +69,28 @@ interface CookieDescriptorOptions<T$1 extends TSchema> {
   /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
-interface AbstractCookieDescriptor<T$1 extends TSchema> {
+interface AbstractCookieDescriptor<T extends TSchema> {
   readonly name: string;
-  readonly options: CookieDescriptorOptions<T$1>;
-  set(value: Static<T$1>, options?: {
+  readonly options: CookieDescriptorOptions<T>;
+  set(value: Static<T>, options?: {
     cookies?: Cookies;
     ttl?: DurationLike;
   }): void;
   get(options?: {
     cookies?: Cookies;
-  }): Static<T$1> | undefined;
+  }): Static<T> | undefined;
   del(options?: {
     cookies?: Cookies;
   }): void;
 }
-declare class CookieDescriptor<T$1 extends TSchema> extends Descriptor<CookieDescriptorOptions<T$1>> implements AbstractCookieDescriptor<T$1> {
+declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescriptorOptions<T>> implements AbstractCookieDescriptor<T> {
   protected readonly serverCookiesProvider: ServerCookiesProvider;
-  get schema(): T$1;
+  get schema(): T;
   get name(): string;
   /**
    * Sets the cookie with the given value in the current request's response.
    */
-  set(value: Static<T$1>, options?: {
+  set(value: Static<T>, options?: {
     cookies?: Cookies;
     ttl?: DurationLike;
   }): void;
@@ -99,7 +99,7 @@ declare class CookieDescriptor<T$1 extends TSchema> extends Descriptor<CookieDes
    */
   get(options?: {
     cookies?: Cookies;
-  }): Static<T$1> | undefined;
+  }): Static<T> | undefined;
   /**
    * Deletes the cookie in the current request's response.
    */

package/server/health.d.ts

@@ -2,11 +2,12 @@ import * as _alepha_core0 from "alepha";
 import { Alepha } from "alepha";
 import * as _alepha_server0 from "alepha/server";
 import { DateTimeProvider } from "alepha/datetime";
-import * as typebox0 from "typebox";
+import * as typebox5 from "typebox";
+import * as dayjs0 from "dayjs";
 
 //#region src/providers/ServerHealthProvider.d.ts
 /**
- * Register `/health` endpoint.
+ * Register `/health` & `/healthz` endpoint.
  *
  * - Provides basic health information about the server.
  */
@@ -14,15 +15,37 @@ declare class ServerHealthProvider {
   protected readonly time: DateTimeProvider;
   protected readonly alepha: Alepha;
   readonly health: _alepha_server0.RouteDescriptor<{
-    response: typebox0.TObject<{
-      message: typebox0.TString;
-      uptime: typebox0.TNumber;
-      date: typebox0.TString;
-      ready: typebox0.TBoolean;
+    response: typebox5.TObject<{
+      message: typebox5.TString;
+      uptime: typebox5.TNumber;
+      date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
+      ready: typebox5.TBoolean;
     }>;
   }>;
+  readonly healthz: _alepha_server0.RouteDescriptor<{
+    response: typebox5.TObject<{
+      message: typebox5.TString;
+      uptime: typebox5.TNumber;
+      date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
+      ready: typebox5.TBoolean;
+    }>;
+  }>;
+  protected healthCheck(): {
+    message: string;
+    uptime: number;
+    date: dayjs0.Dayjs;
+    ready: boolean;
+  };
 }
 //#endregion
+//#region src/schemas/healthSchema.d.ts
+declare const healthSchema: typebox5.TObject<{
+  message: typebox5.TString;
+  uptime: typebox5.TNumber;
+  date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
+  ready: typebox5.TBoolean;
+}>;
+//#endregion
 //#region src/index.d.ts
 /**
  * Plugin for Alepha Server that provides health-check endpoints.
@@ -32,5 +55,5 @@ declare class ServerHealthProvider {
  */
 declare const AlephaServerHealth: _alepha_core0.Service<_alepha_core0.Module<{}>>;
 //#endregion
-export { AlephaServerHealth, ServerHealthProvider };
+export { AlephaServerHealth, ServerHealthProvider, healthSchema };
 //# sourceMappingURL=index.d.ts.map

package/server/links.d.ts

@@ -93,9 +93,9 @@ interface ClientScope {
   service?: string;
   hostname?: string;
 }
-type HttpVirtualClient<T$1> = { [K in keyof T$1 as T$1[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T$1[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
-interface VirtualAction<T$1 extends RequestConfigSchema> extends Pick<ActionDescriptor<T$1>, "name" | "run" | "fetch"> {
-  (config?: ClientRequestEntry<T$1>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T$1>>;
+type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
+interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionDescriptor<T>, "name" | "run" | "fetch"> {
+  (config?: ClientRequestEntry<T>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T>>;
   can: () => boolean;
 }
 //#endregion

package/server/multipart.d.ts

@@ -1,8 +1,8 @@
 import * as _alepha_core0 from "alepha";
 import { Alepha, FileLike, HookDescriptor } from "alepha";
 import { ServerRoute } from "alepha/server";
-import { BusboyConfig } from "@fastify/busboy";
 import { IncomingMessage } from "node:http";
+import { BusboyConfig } from "@fastify/busboy";
 
 //#region src/providers/ServerMultipartProvider.d.ts
 declare class ServerMultipartProvider {
@@ -10,7 +10,7 @@ declare class ServerMultipartProvider {
   readonly onRequest: HookDescriptor<"server:onRequest">;
   readonly onSend: HookDescriptor<"server:onResponse">;
   handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
-    body: Record<string, any>;
+    body: Record<string, unknown>;
     cleanup: () => Promise<void>;
   }>;
   parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;

package/server/swagger.d.ts

@@ -103,6 +103,9 @@ declare class ServerSwaggerProvider {
   protected readonly alepha: Alepha;
   protected readonly log: _alepha_logger0.Logger;
   json?: OpenAPIV3.Document;
+  options: {
+    excludeKeys: string[];
+  };
   protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
   createSwagger(options: SwaggerDescriptorOptions): Promise<OpenAPIV3.Document | undefined>;
   protected configureOpenApi(actions: ActionDescriptor<RequestConfigSchema>[], doc: SwaggerDescriptorOptions): OpenAPIV3.Document;
@@ -115,6 +118,7 @@ declare class ServerSwaggerProvider {
   } | undefined;
   protected configureSwaggerApi(prefix: string, json: OpenAPIV3.Document): void;
   protected configureSwaggerUi(prefix: string, options: SwaggerDescriptorOptions): Promise<void>;
+  removePrivateFields<T extends Record<string, any>>(obj: T, excludeList: string[]): T;
 }
 //#endregion
 //#region src/index.d.ts

package/server.d.ts

@@ -68,14 +68,14 @@ interface RequestConfigSchema {
   headers?: TObject;
   response?: TResponseBody;
 }
-interface ServerRequestConfig<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> {
-  body: TConfig$1["body"] extends TRequestBody ? Static<TConfig$1["body"]> : any;
-  headers: TConfig$1["headers"] extends TObject ? Static<TConfig$1["headers"]> : Record<string, string>;
-  params: TConfig$1["params"] extends TObject ? Static<TConfig$1["params"]> : Record<string, string>;
-  query: TConfig$1["query"] extends TObject ? Static<TConfig$1["query"]> : Record<string, any>;
-}
-type ServerRequestConfigEntry<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig$1>>;
-interface ServerRequest<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig$1> {
+interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
+  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
+  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
+  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
+}
+type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
+interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
   method: RouteMethod;
   url: URL;
   requestId: string;
@@ -120,19 +120,19 @@ interface ServerRequest<TConfig$1 extends RequestConfigSchema = RequestConfigSch
     };
   };
 }
-interface ServerRoute<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> extends Route {
-  handler: ServerHandler<TConfig$1>;
+interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
+  handler: ServerHandler<TConfig>;
   method?: RouteMethod;
-  schema?: TConfig$1;
+  schema?: TConfig;
   /**
    * @see ServerLoggerProvider
    */
   silent?: boolean;
 }
-type ServerResponseBody<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = TConfig$1["response"] extends TResponseBody ? Static<TConfig$1["response"]> : ResponseBodyType;
+type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
 type ResponseKind = "json" | "text" | "void" | "file" | "any";
 type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
-type ServerHandler<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig$1>) => Async<ServerResponseBody<TConfig$1>>;
+type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
 interface ServerResponse {
   body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
   headers: Record<string, string>;
@@ -238,9 +238,7 @@ declare class HttpClient {
   readonly cache: _alepha_cache0.CacheDescriptorFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
   fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
-  fetch<T>(url: string, request?: RequestInit,
-  // standard options
-  options?: FetchOptions): Promise<FetchResponse<T>>;
+  fetch<T extends TSchema>(url: string, request?: RequestInitWithOptions<T>): Promise<FetchResponse<Static<T>>>;
   protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
   protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
   protected responseData(response: Response, options: FetchOptions): Promise<any>;
@@ -257,7 +255,7 @@ declare class HttpClient {
     };
   }, args?: ServerRequestConfigEntry): string;
 }
-interface FetchOptions {
+interface FetchOptions<T extends TSchema = TSchema> {
   /**
    * Key to identify the request in the pending requests.
    */
@@ -265,14 +263,17 @@ interface FetchOptions {
   /**
    * The schema to validate the response against.
    */
-  schema?: TSchema;
+  schema?: {
+    response?: T;
+  };
   /**
    * Built-in cache options.
    */
-  cache?: boolean | number | DurationLike;
+  localCache?: boolean | number | DurationLike;
 }
-interface FetchResponse<T$1 = any> {
-  data: T$1;
+type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
+interface FetchResponse<T = any> {
+  data: T;
   status: number;
   statusText: string;
   headers: Headers;
@@ -485,7 +486,7 @@ declare const $action: {
   <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptorFn<TConfig>;
   [KIND]: typeof ActionDescriptor;
 };
-interface ActionDescriptorOptions<TConfig$1 extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
+interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
    * Name of the action.
    *
@@ -536,7 +537,7 @@ interface ActionDescriptorOptions<TConfig$1 extends RequestConfigSchema> extends
    * - query: The request query-params schema.
    * - response: The response schema.
    */
-  schema?: TConfig$1;
+  schema?: TConfig;
   /**
    * A short description of the action. Used for documentation purposes.
    */
@@ -549,9 +550,9 @@ interface ActionDescriptorOptions<TConfig$1 extends RequestConfigSchema> extends
   /**
    * Main route handler. This is where the route logic is implemented.
    */
-  handler: ServerActionHandler<TConfig$1>;
+  handler: ServerActionHandler<TConfig>;
 }
-declare class ActionDescriptor<TConfig$1 extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig$1>> {
+declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
   protected readonly log: _alepha_logger3.Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
@@ -580,27 +581,27 @@ declare class ActionDescriptor<TConfig$1 extends RequestConfigSchema> extends De
    * Path is prefixed by `/api` by default.
    */
   get path(): string;
-  get schema(): TConfig$1 | undefined;
+  get schema(): TConfig | undefined;
   getBodyContentType(): string | undefined;
   /**
    * Call the action handler directly.
    * There is no HTTP layer involved.
    */
-  run(config?: ClientRequestEntry<TConfig$1>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig$1>>;
+  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
   /**
    * Works like `run`, but always fetches (http request) the route.
    */
-  fetch(config?: ClientRequestEntry<TConfig$1>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig$1>>>;
+  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
-interface ActionDescriptorFn<TConfig$1 extends RequestConfigSchema> extends ActionDescriptor<TConfig$1> {
-  (config?: ClientRequestEntry<TConfig$1>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig$1>>;
+interface ActionDescriptorFn<TConfig extends RequestConfigSchema> extends ActionDescriptor<TConfig> {
+  (config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
 }
-type ClientRequestEntry<TConfig$1 extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig$1>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
-type ClientRequestEntryContainer<TConfig$1 extends RequestConfigSchema> = {
-  body: TConfig$1["body"] extends TObject ? Static<TConfig$1["body"]> : undefined;
-  params: TConfig$1["params"] extends TObject ? Static<TConfig$1["params"]> : undefined;
-  headers?: TConfig$1["headers"] extends TObject ? Static<TConfig$1["headers"]> : undefined;
-  query?: TConfig$1["query"] extends TObject ? Partial<Static<TConfig$1["query"]>> : undefined;
+type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
+type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
+  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
+  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
+  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
 };
 interface ClientRequestOptions extends FetchOptions {
   /**
@@ -608,11 +609,11 @@ interface ClientRequestOptions extends FetchOptions {
    */
   request?: RequestInit;
 }
-type ClientRequestResponse<TConfig$1 extends RequestConfigSchema> = TConfig$1["response"] extends TSchema ? Static<TConfig$1["response"]> : any;
+type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
 /**
  * Specific handler for server actions.
  */
-type ServerActionHandler<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig$1>) => Async<ServerResponseBody<TConfig$1>>;
+type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
 /**
  * Server Action Request Interface
  *
@@ -620,7 +621,7 @@ type ServerActionHandler<TConfig$1 extends RequestConfigSchema = RequestConfigSc
  *
  * This is NOT Server Request, but a specific type for actions.
  */
-interface ServerActionRequest<TConfig$1 extends RequestConfigSchema> extends ServerRequest<TConfig$1> {}
+interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
 //#endregion
 //#region src/schemas/errorSchema.d.ts
 declare const errorSchema: typebox0.TObject<{
@@ -670,8 +671,8 @@ declare const $route: {
   <TConfig extends RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
   [KIND]: typeof RouteDescriptor;
 };
-interface RouteDescriptorOptions<TConfig$1 extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig$1> {}
-declare class RouteDescriptor<TConfig$1 extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig$1>> {
+interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
+declare class RouteDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig>> {
   protected readonly serverRouterProvider: ServerRouterProvider;
   protected onInit(): void;
 }
@@ -843,5 +844,5 @@ declare module "alepha" {
  */
 declare const AlephaServer: _alepha_core11.Service<_alepha_core11.Module<{}>>;
 //#endregion
-export { $action, $route, ActionDescriptor, ActionDescriptorFn, ActionDescriptorOptions, AlephaServer, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
+export { $action, $route, ActionDescriptor, ActionDescriptorFn, ActionDescriptorOptions, AlephaServer, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, RequestInitWithOptions, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
 //# sourceMappingURL=index.d.ts.map

package/topic.d.ts

@@ -220,7 +220,7 @@ declare const $topic: {
   <T extends TopicMessageSchema>(options: TopicDescriptorOptions<T>): TopicDescriptor<T>;
   [KIND]: typeof TopicDescriptor;
 };
-interface TopicDescriptorOptions<T$1 extends TopicMessageSchema> {
+interface TopicDescriptorOptions<T extends TopicMessageSchema> {
   /**
    * Unique name identifier for the topic.
    *
@@ -329,7 +329,7 @@ interface TopicDescriptorOptions<T$1 extends TopicMessageSchema> {
    * }
    * ```
    */
-  schema: T$1;
+  schema: T;
   /**
    * Default subscriber handler function that processes messages published to this topic.
    *
@@ -393,32 +393,32 @@ interface TopicDescriptorOptions<T$1 extends TopicMessageSchema> {
    * }
    * ```
    */
-  handler?: TopicHandler<T$1>;
+  handler?: TopicHandler<T>;
 }
-declare class TopicDescriptor<T$1 extends TopicMessageSchema> extends Descriptor<TopicDescriptorOptions<T$1>> {
+declare class TopicDescriptor<T extends TopicMessageSchema> extends Descriptor<TopicDescriptorOptions<T>> {
   protected readonly log: _alepha_logger0.Logger;
   protected readonly dateTimeProvider: DateTimeProvider;
   readonly provider: TopicProvider;
   get name(): string;
-  publish(payload: TopicMessage<T$1>["payload"]): Promise<void>;
-  subscribe(handler: TopicHandler<T$1>): Promise<UnSubscribeFn>;
-  wait(options?: TopicWaitOptions<T$1>): Promise<TopicMessage<T$1>>;
+  publish(payload: TopicMessage<T>["payload"]): Promise<void>;
+  subscribe(handler: TopicHandler<T>): Promise<UnSubscribeFn>;
+  wait(options?: TopicWaitOptions<T>): Promise<TopicMessage<T>>;
   protected $provider(): TopicProvider;
-  protected parseMessage(message: string): TopicMessage<T$1>;
+  protected parseMessage(message: string): TopicMessage<T>;
 }
-interface TopicMessage<T$1 extends TopicMessageSchema> {
-  payload: Static<T$1["payload"]>;
+interface TopicMessage<T extends TopicMessageSchema> {
+  payload: Static<T["payload"]>;
 }
-interface TopicWaitOptions<T$1 extends TopicMessageSchema> {
+interface TopicWaitOptions<T extends TopicMessageSchema> {
   timeout?: DurationLike;
   filter?: (message: {
-    payload: Static<T$1["payload"]>;
+    payload: Static<T["payload"]>;
   }) => boolean;
 }
 interface TopicMessageSchema {
   payload: TSchema;
 }
-type TopicHandler<T$1 extends TopicMessageSchema = TopicMessageSchema> = (message: TopicMessage<T$1>) => unknown;
+type TopicHandler<T extends TopicMessageSchema = TopicMessageSchema> = (message: TopicMessage<T>) => unknown;
 //#endregion
 //#region src/descriptors/$subscriber.d.ts
 /**
@@ -636,7 +636,7 @@ declare const $subscriber: {
   <T extends TopicMessageSchema>(options: SubscriberDescriptorOptions<T>): SubscriberDescriptor<T>;
   [KIND]: typeof SubscriberDescriptor;
 };
-interface SubscriberDescriptorOptions<T$1 extends TopicMessageSchema> {
+interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
   /**
    * The topic descriptor that this subscriber will listen to for messages.
    *
@@ -670,7 +670,7 @@ interface SubscriberDescriptorOptions<T$1 extends TopicMessageSchema> {
    * });
    * ```
    */
-  topic: TopicDescriptor<T$1>;
+  topic: TopicDescriptor<T>;
   /**
    * Message handler function that processes individual messages from the topic.
    *
@@ -765,9 +765,9 @@ interface SubscriberDescriptorOptions<T$1 extends TopicMessageSchema> {
    * }
    * ```
    */
-  handler: TopicHandler<T$1>;
+  handler: TopicHandler<T>;
 }
-declare class SubscriberDescriptor<T$1 extends TopicMessageSchema> extends Descriptor<SubscriberDescriptorOptions<T$1>> {}
+declare class SubscriberDescriptor<T extends TopicMessageSchema> extends Descriptor<SubscriberDescriptorOptions<T>> {}
 //#endregion
 //#region src/errors/TopicTimeoutError.d.ts
 declare class TopicTimeoutError extends Error {