alepha 0.8.0 → 0.9.0

package/server/cookies.d.ts

@@ -1,8 +1,53 @@
-import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, Static, TObject, TOptional, TSchema, TString } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, Static, TSchema } from "alepha";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
+//#region src/providers/ServerCookiesProvider.d.ts
+declare const envSchema: _alepha_core0$1.TObject<{
+  /**
+   *  A 32-byte secret key used for cookie encryption and signing. MUST be set for `encrypt` or `sign` to work.
+   */
+  COOKIE_SECRET: _alepha_core0$1.TOptional<_alepha_core0$1.TString>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare class ServerCookiesProvider {
+  protected readonly alepha: Alepha;
+  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly env: {
+    COOKIE_SECRET?: string | undefined;
+  };
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly ALGORITHM = "aes-256-gcm";
+  protected readonly IV_LENGTH = 16;
+  protected readonly AUTH_TAG_LENGTH = 16;
+  protected readonly SIGNATURE_LENGTH = 32;
+  readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core0$1.HookDescriptor<"server:onSend">;
+  protected getCookiesFromContext(cookies?: Cookies): Cookies;
+  getCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, contextCookies?: Cookies): Static<T> | undefined;
+  setCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, data: Static<T>, contextCookies?: Cookies): void;
+  deleteCookie<T extends TSchema>(name: string, contextCookies?: Cookies): void;
+  protected encrypt(text: string): string;
+  protected decrypt(encryptedText: string): string;
+  secretKey(): string;
+  protected sign(data: string): string;
+  protected parseRequestCookies(header: string): Record<string, string>;
+  protected serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
+}
+//#endregion
 //#region src/descriptors/$cookie.d.ts
-declare const KEY = "COOKIE";
+/**
+ * Declares a type-safe, configurable HTTP cookie.
+ * This descriptor provides methods to get, set, and delete the cookie
+ * within the server request/response cycle.
+ */
+declare const $cookie: {
+  <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
+  [KIND]: typeof CookieDescriptor;
+};
 interface CookieDescriptorOptions<T extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
   schema: T;
@@ -27,33 +72,22 @@ interface CookieDescriptorOptions<T extends TSchema> {
   /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
-interface CookieDescriptor<T extends TSchema> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: CookieDescriptorOptions<T>;
-  schema: T;
+declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescriptorOptions<T>> {
+  protected readonly serverCookiesProvider: ServerCookiesProvider;
+  get name(): string;
   /** Sets the cookie with the given value in the current request's response. */
-  set: (value: Static<T>, options?: {
+  set(value: Static<T>, options?: {
     cookies?: Cookies;
-  }) => void;
+  }): void;
   /** Gets the cookie value from the current request. Returns undefined if not found or invalid. */
-  get: (options?: {
+  get(options?: {
     cookies?: Cookies;
-  }) => Static<T> | undefined;
+  }): Static<T> | undefined;
   /** Deletes the cookie in the current request's response. */
-  del: (options?: {
+  del(options?: {
     cookies?: Cookies;
-  }) => void;
+  }): void;
 }
-/**
-* Declares a type-safe, configurable HTTP cookie.
-* This descriptor provides methods to get, set, and delete the cookie
-* within the server request/response cycle.
-*/
-declare const $cookie: {
-  <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
-  [KIND]: string;
-};
-// ---------------------------------------------------------------------------------------------------------------------
 interface Cookies {
   req: Record<string, string>;
   res: Record<string, Cookie | null>;
@@ -67,52 +101,27 @@ interface Cookie {
   sameSite?: "strict" | "lax" | "none";
   domain?: string;
 }
-//#endregion
-//#region src/providers/ServerCookiesProvider.d.ts
-declare const envSchema: TObject<{
-  COOKIE_SECRET: TOptional<TString>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-declare class ServerCookiesProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: Logger;
-  protected readonly env: Static<typeof envSchema>;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  // Crypto constants
-  protected readonly ALGORITHM = "aes-256-gcm";
-  protected readonly IV_LENGTH = 16;
-  protected readonly AUTH_TAG_LENGTH = 16;
-  protected readonly SIGNATURE_LENGTH = 32;
-  protected readonly configure: HookDescriptor<"configure">;
-  protected createApi<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
-  readonly onRequest: HookDescriptor<"server:onRequest">;
-  readonly onSend: HookDescriptor<"server:onSend">;
-  protected getCookiesFromContext(cookies?: Cookies): Cookies;
-  protected getCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, contextCookies?: Cookies): Static<T> | undefined;
-  protected setCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, data: Static<T>, contextCookies?: Cookies): void;
-  protected deleteCookie<T extends TSchema>(name: string, contextCookies?: Cookies): void;
-  // --- Crypto & Parsing ---
-  protected encrypt(text: string): string;
-  protected decrypt(encryptedText: string): string;
-  secretKey(): string;
-  protected sign(data: string): string;
-  protected parseRequestCookies(header: string): Record<string, string>;
-  protected serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
-}
+//# sourceMappingURL=$cookie.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 declare module "alepha/server" {
   interface ServerRequest {
     cookies: Cookies;
   }
 }
-declare class AlephaServerCookies implements Module {
-  readonly name = "alepha.server.cookies";
-  readonly $services: (alepha: Alepha) => void;
-}
+/**
+ * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
+ *
+ * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
+ * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
+ * for managing user sessions, preferences, and authentication tokens.
+ *
+ * @see {@link $cookie}
+ * @module alepha.server.cookies
+ */
+declare const AlephaServerCookies: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $cookie, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/cors.d.ts

@@ -1,29 +1,31 @@
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
 import { ServerRouterProvider } from "alepha/server";
-import { Alepha, HookDescriptor, Module } from "alepha";
 
 //#region src/providers/ServerCorsProvider.d.ts
 declare class ServerCorsProvider {
   protected readonly serverRouterProvider: ServerRouterProvider;
-  options: CorsOptions;
-  protected readonly onRoute: HookDescriptor<"server:onRoute">;
-  protected readonly onRequest: HookDescriptor<"server:onRequest">;
-  isOriginAllowed(origin: string | undefined, allowed: CorsOptions["origin"]): boolean;
+  options: ServerCorsProviderOptions;
+  protected readonly configure: _alepha_core0$1.HookDescriptor<"configure">;
+  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  isOriginAllowed(origin: string | undefined, allowed: ServerCorsProviderOptions["origin"]): boolean;
 }
-// ---------------------------------------------------------------------------------------------------------------------
-interface CorsOptions {
+interface ServerCorsProviderOptions {
   origin?: string | string[] | ((origin: string | undefined) => boolean);
   methods: string[];
   headers: string[];
   credentials?: boolean;
   maxAge?: number;
 }
+//# sourceMappingURL=ServerCorsProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
-declare class AlephaServerCors implements Module {
-  readonly name = "alepha.server.cors";
-  readonly $services: (alepha: Alepha) => void;
-}
+/**
+ * Plugin for configuring CORS on the Alepha server.
+ */
+declare const AlephaServerCors: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { AlephaServerCors, CorsOptions, ServerCorsProvider };
+export { AlephaServerCors, ServerCorsProvider, ServerCorsProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/server/health.d.ts

@@ -1,42 +1,39 @@
-import { RouteDescriptor } from "alepha/server";
-import { Alepha, TBoolean, TNumber, TObject, TString } from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha } from "alepha";
+import * as _alepha_server0 from "alepha/server";
 import { DateTimeProvider } from "alepha/datetime";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/providers/ServerHealthProvider.d.ts
-
 /**
-* Register `/health` endpoint.
-*
-* - Provides basic health information about the server.
-*/
+ * Register `/health` endpoint.
+ *
+ * - Provides basic health information about the server.
+ */
 declare class ServerHealthProvider {
   protected readonly time: DateTimeProvider;
   protected readonly alepha: Alepha;
-  readonly health: RouteDescriptor<{
-    response: TObject<{
-      message: TString;
-      uptime: TNumber;
-      date: TString;
-      ready: TBoolean;
+  readonly health: _alepha_server0.RouteDescriptor<{
+    response: _sinclair_typebox0.TObject<{
+      message: _sinclair_typebox0.TString;
+      uptime: _sinclair_typebox0.TNumber;
+      date: _sinclair_typebox0.TString;
+      ready: _sinclair_typebox0.TBoolean;
     }>;
   }>;
 }
+//# sourceMappingURL=ServerHealthProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Alepha Server Health Module
-*
-* @description
-* Plugin for Alepha Server that provides health-check endpoints.
-*
-* @see {@link ServerHealthProvider}
-* @module alepha.server.health
-*/
-declare class AlephaServerHealth {
-  readonly name = "alepha.server.health";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * Plugin for Alepha Server that provides health-check endpoints.
+ *
+ * @see {@link ServerHealthProvider}
+ * @module alepha.server.health
+ */
+declare const AlephaServerHealth: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerHealth, ServerHealthProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/helmet.d.ts

@@ -1,4 +1,5 @@
-import { Alepha, HookDescriptor, Module } from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, HookDescriptor } from "alepha";
 
 //#region src/providers/ServerHelmetProvider.d.ts
 type CspDirective = string | string[];
@@ -38,35 +39,31 @@ interface HelmetOptions {
   referrerPolicy?: "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | false;
 }
 /**
-* Provides a configurable way to apply essential HTTP security headers
-* to every server response, without external dependencies.
-*/
+ * Provides a configurable way to apply essential HTTP security headers
+ * to every server response, without external dependencies.
+ */
 declare class ServerHelmetProvider {
   protected readonly alepha: Alepha;
   /**
-  * The configuration options. These can be overridden during
-  * the application's configuration phase using `alepha.configure()`.
-  */
+   * The configuration options. These can be overridden during
+   * the application's configuration phase using `alepha.configure()`.
+   */
   options: HelmetOptions;
   private buildHeaders;
   protected readonly onResponse: HookDescriptor<"server:onResponse">;
 }
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Alepha Server Helmet Module
-*
-* Automatically adds important HTTP security headers to every response
-* to help protect your application from common web vulnerabilities.
-*
-* @see {@link ServerHelmetProvider}
-* @module alepha.server.helmet
-*/
-declare class AlephaServerHelmet implements Module {
-  readonly name = "alepha.server.helmet";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * Automatically adds important HTTP security headers to every response
+ * to help protect your application from common web vulnerabilities.
+ *
+ * @see {@link ServerHelmetProvider}
+ * @module alepha.server.helmet
+ */
+declare const AlephaServerHelmet: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerHelmet, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/links.d.ts

@@ -1,8 +1,13 @@
-import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, TAny, TArray, TObject, TOptional, TRecord, TString } from "alepha";
-import { ActionDescriptor, ActionDescriptorHelper, ApiLink, ApiLinksResponse, ClientRequestOptions, FetchResponse, HttpClient, RequestConfigSchema, RouteDescriptor, ServerActionDescriptorProvider, ServerHandler, ServerRemote, ServerRequestConfigEntry } from "alepha/server";
-import { RetryDescriptor } from "alepha/retry";
-import { ProxyDescriptorOptions, ProxyDescriptorProvider } from "alepha/server/proxy";
+import * as _alepha_core1 from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, Logger } from "alepha";
+import * as _alepha_server0 from "alepha/server";
+import { ActionDescriptor, ApiLink, ApiLinksResponse, ClientRequestEntry, ClientRequestOptions, ClientRequestResponse, FetchResponse, HttpClient, RequestConfigSchema, ServerHandler, ServerRequestConfigEntry } from "alepha/server";
+import * as _alepha_retry0 from "alepha/retry";
+import { ProxyDescriptorOptions, ServerProxyProvider } from "alepha/server/proxy";
 import { ServiceAccountDescriptor, UserAccountToken } from "alepha/security";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/providers/LinkProvider.d.ts
 declare class LinkProvider {
@@ -15,24 +20,20 @@ declare class LinkProvider {
   getLinks(force?: boolean): Promise<HttpClientLink[]>;
   client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
   /**
-  * Resolve a link by its name and call it.
-  * - If link is local, it will call the local handler.
-  * - If link is remote, it will make a fetch request to the remote server.
-  */
+   * Resolve a link by its name and call it.
+   * - If link is local, it will call the local handler.
+   * - If link is remote, it will make a fetch request to the remote server.
+   */
   follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
   protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
   can(name: string): boolean;
   protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
 }
-// ---------------------------------------------------------------------------------------------------------------------
 interface HttpClientLink extends ApiLink {
   secured?: boolean;
   prefix?: string;
-  // -- server only --
-  // only for remote actions
   host?: string;
   service?: string;
-  // used only for local actions, not for remote actions
   schema?: RequestConfigSchema;
   handler?: ServerHandler;
 }
@@ -40,77 +41,86 @@ interface ClientScope {
   group?: string;
   service?: string;
 }
-type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? T[K] & {
+type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? T[K] & {
+  (config?: ClientRequestEntry<Schema>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<Schema>>;
   can: () => boolean;
   schema: Schema;
 } : never };
+//# sourceMappingURL=LinkProvider.d.ts.map
 //#endregion
 //#region src/descriptors/$client.d.ts
-declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
+/**
+ * Create a new client.
+ */
+declare const $client: {
+  <T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
+  [KIND]: string;
+};
+//# sourceMappingURL=$client.d.ts.map
+
 //#endregion
 //#region src/descriptors/$remote.d.ts
-declare const KEY = "REMOTE";
+/**
+ * $remote is a descriptor that allows you to define remote service access.
+ *
+ * Use it only when you have 2 or more services that need to communicate with each other.
+ *
+ * All remote services can be exposed as actions, ... or not.
+ *
+ * You can add a service account if you want to use a security layer.
+ */
+declare const $remote: {
+  (options: RemoteDescriptorOptions): RemoteDescriptor;
+  [KIND]: typeof RemoteDescriptor;
+};
 interface RemoteDescriptorOptions {
   /**
-  * The URL of the remote service.
-  * You can use a function to generate the URL dynamically.
-  * You probably should use $inject(env) to get the URL from the environment.
-  *
-  * @example
-  * ```ts
-  * import { $remote } from "alepha/server";
-  * import { $inject, t } from "alepha";
-  *
-  * class App {
-  *   env = $inject(t.object({
-  *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
-  *   }));
-  *   remote = $remote({
-  *     url: this.env.REMOTE_URL,
-  *   });
-  * }
-  * ```
-  */
+   * The URL of the remote service.
+   * You can use a function to generate the URL dynamically.
+   * You probably should use $env(env) to get the URL from the environment.
+   *
+   * @example
+   * ```ts
+   * import { $remote } from "alepha/server";
+   * import { $inject, t } from "alepha";
+   *
+   * class App {
+   *   env = $env(t.object({
+   *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
+   *   }));
+   *   remote = $remote({
+   *     url: this.env.REMOTE_URL,
+   *   });
+   * }
+   * ```
+   */
   url: string | (() => string);
   /**
-  * The name of the remote service.
-  *
-  * @default Member of the class containing the remote service.
-  */
+   * The name of the remote service.
+   *
+   * @default Member of the class containing the remote service.
+   */
   name?: string;
   /**
-  * If true, all methods of the remote service will be exposed as actions in this context.
-  * > Note: Proxy will never use the service account, it just... proxies the request.
-  */
+   * If true, all methods of the remote service will be exposed as actions in this context.
+   * > Note: Proxy will never use the service account, it just... proxies the request.
+   */
   proxy?: boolean | Partial<ProxyDescriptorOptions & {
     /**
-    * If true, the remote service won't be available internally, only through the proxy.
-    */
+     * If true, the remote service won't be available internally, only through the proxy.
+     */
     noInternal: boolean;
   }>;
   /**
-  * For communication between the server and the remote service with a security layer.
-  * This will be used for internal communication and will not be exposed to the client.
-  */
+   * For communication between the server and the remote service with a security layer.
+   * This will be used for internal communication and will not be exposed to the client.
+   */
   serviceAccount?: ServiceAccountDescriptor;
 }
-interface RemoteDescriptor {
-  [KIND]: typeof KEY;
-  [OPTIONS]: RemoteDescriptorOptions;
+declare class RemoteDescriptor extends Descriptor<RemoteDescriptorOptions> {
+  get name(): string;
 }
-/**
-* $remote is a descriptor that allows you to define a remote service access.
-*
-* Use it only when you have 2 or more services that need to communicate with each other.
-*
-* All remote services can be exposed as actions, ... or not.
-*
-* You can add a service account if you want to use a security layer.
-*/
-declare const $remote: {
-  (options: RemoteDescriptorOptions): RemoteDescriptor;
-  [KIND]: string;
-};
+//# sourceMappingURL=$remote.d.ts.map
 //#endregion
 //#region src/providers/RemoteDescriptorProvider.d.ts
 declare class RemoteDescriptorProvider {
@@ -119,47 +129,61 @@ declare class RemoteDescriptorProvider {
   };
   protected readonly alepha: Alepha;
   protected readonly client: LinkProvider;
-  protected readonly proxyProvider: ProxyDescriptorProvider;
+  protected readonly proxyProvider: ServerProxyProvider;
   protected readonly remotes: Array<ServerRemote>;
   protected readonly log: Logger;
   getRemotes(): ServerRemote[];
-  readonly configure: HookDescriptor<"configure">;
-  readonly start: HookDescriptor<"start">;
-  registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
-  protected readonly fetchLinks: RetryDescriptor<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
+  readonly configure: _alepha_core1.HookDescriptor<"configure">;
+  readonly start: _alepha_core1.HookDescriptor<"start">;
+  registerRemote(value: RemoteDescriptor): Promise<void>;
+  protected readonly fetchLinks: _alepha_retry0.RetryDescriptorFn<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
 }
 interface FetchLinksOptions {
   service: string;
   url: string;
   authorization?: string;
 }
+interface ServerRemote {
+  url: string;
+  name: string;
+  proxy: boolean;
+  internal: boolean;
+  links: (args: {
+    authorization?: string;
+  }) => Promise<ApiLinksResponse>;
+  schema: (args: {
+    name: string;
+    authorization?: string;
+  }) => Promise<any>;
+  serviceAccount?: ServiceAccountDescriptor;
+  prefix: string;
+}
+//# sourceMappingURL=RemoteDescriptorProvider.d.ts.map
 //#endregion
 //#region src/providers/ServerLinksProvider.d.ts
 declare class ServerLinksProvider {
   protected readonly alepha: Alepha;
   protected readonly client: LinkProvider;
-  protected readonly helper: ActionDescriptorHelper;
   protected readonly remoteProvider: RemoteDescriptorProvider;
-  protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
-  readonly onRoute: HookDescriptor<"server:onRoute">;
-  readonly links: RouteDescriptor<{
-    response: TObject<{
-      prefix: TOptional<TString>;
-      links: TArray<TObject<{
-        name: TString;
-        path: TString;
-        method: TOptional<TString>;
-        group: TOptional<TString>;
-        requestBodyType: TOptional<TString>;
-        service: TOptional<TString>;
+  readonly onRoute: _alepha_core0$1.HookDescriptor<"configure">;
+  readonly links: _alepha_server0.RouteDescriptor<{
+    response: _sinclair_typebox0.TObject<{
+      prefix: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+      links: _sinclair_typebox0.TArray<_sinclair_typebox0.TObject<{
+        name: _sinclair_typebox0.TString;
+        path: _sinclair_typebox0.TString;
+        method: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+        group: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+        requestBodyType: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+        service: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
       }>>;
     }>;
   }>;
-  readonly schema: RouteDescriptor<{
-    params: TObject<{
-      name: TString;
+  readonly schema: _alepha_server0.RouteDescriptor<{
+    params: _sinclair_typebox0.TObject<{
+      name: _sinclair_typebox0.TString;
     }>;
-    response: TRecord<TString, TAny>;
+    response: _sinclair_typebox0.TRecord<_sinclair_typebox0.TString, _sinclair_typebox0.TAny>;
   }>;
   getLinks(options: GetLinksOptions): Promise<ApiLinksResponse>;
 }
@@ -167,13 +191,12 @@ interface GetLinksOptions {
   user?: UserAccountToken;
   authorization?: string;
 }
+//# sourceMappingURL=ServerLinksProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
-declare class AlephaServerLinks implements Module {
-  readonly name = "alepha.server.links";
-  readonly $services: (alepha: Alepha) => void;
-}
+declare const AlephaServerLinks: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { $client, $remote, AlephaServerLinks, ClientScope, FetchLinksOptions, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider };
+export { $client, $remote, AlephaServerLinks, ClientScope, FetchLinksOptions, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider, ServerRemote };
 //# sourceMappingURL=index.d.ts.map