alepha 0.8.0 → 0.9.0

package/server/metrics.d.ts

@@ -1,37 +1,39 @@
-import { RouteDescriptor } from "alepha/server";
-import { Alepha, HookDescriptor, Module } from "alepha";
-import { Registry } from "prom-client";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha } from "alepha";
+import * as _alepha_server0 from "alepha/server";
+import { Histogram, Registry } from "prom-client";
 
 //#region src/providers/ServerMetricsProvider.d.ts
+declare class ServerMetricsProvider {
+  protected readonly register: Registry;
+  protected readonly alepha: Alepha;
+  protected httpRequestDuration?: Histogram<string>;
+  readonly options: ServerMetricsProviderOptions;
+  readonly metrics: _alepha_server0.RouteDescriptor<_alepha_server0.RequestConfigSchema>;
+  protected readonly onStart: _alepha_core0$1.HookDescriptor<"start">;
+  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  protected readonly onResponse: _alepha_core0$1.HookDescriptor<"server:onResponse">;
+}
 interface ServerMetricsProviderOptions {
   prefix?: string;
   gcDurationBuckets?: number[];
   eventLoopMonitoringPrecision?: number;
   labels?: object;
 }
-declare class ServerMetricsProvider {
-  protected readonly register: Registry;
-  protected readonly alepha: Alepha;
-  readonly options: ServerMetricsProviderOptions;
-  readonly metrics: RouteDescriptor;
-  protected readonly onStart: HookDescriptor<"start">;
-}
+//# sourceMappingURL=ServerMetricsProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Alepha Server Metrics Module
-*
-* This module provides prometheus metrics for the Alepha server.
-* Metrics are exposed at the `/metrics` endpoint.
-*
-* @see {@link ServerMetricsProvider}
-* @module alepha.server.metrics
-*/
-declare class AlephaServerMetrics implements Module {
-  readonly name = "alepha.server.metrics";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * This module provides prometheus metrics for the Alepha server.
+ * Metrics are exposed at the `/metrics` endpoint.
+ *
+ * @see {@link ServerMetricsProvider}
+ * @module alepha.server.metrics
+ */
+declare const AlephaServerMetrics: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerMetrics, ServerMetricsProvider, ServerMetricsProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/server/multipart.d.ts

@@ -1,11 +1,11 @@
-import { ActionDescriptorHelper, ServerRoute } from "alepha/server";
-import { Alepha, FileLike, HookDescriptor, Module } from "alepha";
+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";
 
 //#region src/providers/ServerMultipartProvider.d.ts
 declare class ServerMultipartProvider {
-  protected readonly helper: ActionDescriptorHelper;
   protected readonly alepha: Alepha;
   readonly onRequest: HookDescriptor<"server:onRequest">;
   readonly onSend: HookDescriptor<"server:onResponse">;
@@ -29,20 +29,16 @@ interface HybridFile extends FileLike {
 }
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Alepha Server Multipart Module
-*
-* This module provides support for handling multipart/form-data requests.
-* It allows to parse body data containing t.file().
-*
-* @see {@link ServerMultipartProvider}
-* @module alepha.server.multipart
-*/
-declare class AlephaServerMultipart implements Module {
-  readonly name = "alepha.server.multipart";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * This module provides support for handling multipart/form-data requests.
+ * It allows to parse body data containing t.file().
+ *
+ * @see {@link ServerMultipartProvider}
+ * @module alepha.server.multipart
+ */
+declare const AlephaServerMultipart: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaServerMultipart, ServerMultipartProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/proxy.d.ts

@@ -1,7 +1,13 @@
-import { Alepha, Async, HookDescriptor, KIND, Logger, Module, OPTIONS } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Async, Descriptor, KIND } from "alepha";
 import { ServerHandler, ServerRequest, ServerRouterProvider } from "alepha/server";
 
 //#region src/descriptors/$proxy.d.ts
+declare const $proxy: {
+  (options: ProxyDescriptorOptions): ProxyDescriptor;
+  [KIND]: typeof ProxyDescriptor;
+};
 type ProxyDescriptorOptions = {
   path: string;
   target: string | (() => string);
@@ -10,32 +16,31 @@ type ProxyDescriptorOptions = {
   afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
   rewrite?: (url: URL) => void;
 };
-interface ProxyDescriptor {
-  [KIND]: "PROXY";
-  [OPTIONS]: ProxyDescriptorOptions;
-}
-declare const $proxy: {
-  (options: ProxyDescriptorOptions): ProxyDescriptor;
-  [KIND]: string;
-};
+declare class ProxyDescriptor extends Descriptor<ProxyDescriptorOptions> {}
+//# sourceMappingURL=$proxy.d.ts.map
 //#endregion
-//#region src/providers/ProxyDescriptorProvider.d.ts
-declare class ProxyDescriptorProvider {
-  protected readonly log: Logger;
+//#region src/providers/ServerProxyProvider.d.ts
+declare class ServerProxyProvider {
+  protected readonly log: _alepha_core0$1.Logger;
   protected readonly routerProvider: ServerRouterProvider;
   protected readonly alepha: Alepha;
-  readonly configure: HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core0$1.HookDescriptor<"configure">;
+  createProxy(options: ProxyDescriptorOptions): void;
   createProxyHandler(target: string, options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
-  proxy(options: ProxyDescriptorOptions): Promise<void>;
   private getRawRequestBody;
 }
+//# sourceMappingURL=ServerProxyProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
-declare class AlephaServerProxy implements Module {
-  readonly name = "alepha.server.proxy";
-  readonly $services: (alepha: Alepha) => void;
-}
+/**
+ * Plugin for Alepha that provides a proxy server functionality.
+ *
+ * @see {@link $proxy}
+ * @module alepha.server.proxy
+ */
+declare const AlephaServerProxy: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { $proxy, AlephaServerProxy, ProxyDescriptor, ProxyDescriptorOptions, ProxyDescriptorProvider };
+export { $proxy, AlephaServerProxy, ProxyDescriptor, ProxyDescriptorOptions, ServerProxyProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/security.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-security');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/server/security.d.ts

@@ -0,0 +1,90 @@
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha } from "alepha";
+import { JwtProvider, Permission, SecurityProvider, UserAccountToken } from "alepha/security";
+import { FetchOptions } from "alepha/server";
+
+//#region src/providers/ServerSecurityProvider.d.ts
+declare class ServerSecurityProvider {
+  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly securityProvider: SecurityProvider;
+  protected readonly jwtProvider: JwtProvider;
+  protected readonly alepha: Alepha;
+  protected readonly onConfigure: _alepha_core0$1.HookDescriptor<"configure">;
+  protected readonly onActionRequest: _alepha_core0$1.HookDescriptor<"action:onRequest">;
+  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  /**
+   * Get the user account token for a local action call.
+   * There are three possible sources for the user:
+   * - `options.user`: the user passed in the options
+   * - `"system"`: the system user from the state (you MUST set state `server.security.system.user`)
+   * - `"context"`: the user from the request context (you MUST be in an HTTP request context)
+   *
+   * Priority order: `options.user` > `"system"` > `"context"`.
+   *
+   * In testing environment, if no user is provided, a test user is created based on the SecurityProvider's roles.
+   */
+  protected createUserFromLocalFunctionContext(options: {
+    user?: UserAccountToken | "system" | "context";
+  }, permission?: Permission): UserAccountToken;
+  protected createTestUser(): UserAccountToken;
+  protected readonly onClientRequest: _alepha_core0$1.HookDescriptor<"client:onRequest">;
+}
+type ServerRouteSecure = boolean | {
+  permissions?: string[];
+  roles?: string[];
+  realms?: string[];
+  organizations?: string[];
+};
+//# sourceMappingURL=ServerSecurityProvider.d.ts.map
+//#endregion
+//#region src/index.d.ts
+declare module "alepha" {
+  interface State {
+    /**
+     * Real (or fake) user account, used for internal actions.
+     *
+     * If you define this, you assume that all actions are executed by this user by default.
+     * > To force a different user, you need to pass it explicitly in the options.
+     */
+    "server.security.system.user"?: UserAccountToken;
+  }
+}
+declare module "alepha/server" {
+  interface ServerRequest<TConfig> {
+    user?: UserAccountToken;
+  }
+  interface ServerActionRequest<TConfig> {
+    user: UserAccountToken;
+  }
+  interface ServerRoute {
+    /**
+     * If true, the route will be protected by the security provider.
+     * All actions are secure by default, but you can disable it for specific actions.
+     */
+    secure?: boolean;
+  }
+  interface ClientRequestOptions extends FetchOptions {
+    /**
+     * Forward user from the previous request.
+     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
+     * If "context", use the user from the current context (e.g. request).
+     *
+     * @default "system" is provided, else "context" is used.
+     */
+    user?: UserAccountToken | "system" | "context";
+  }
+}
+/**
+ * Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
+ *
+ * By default, all $action will be guarded by a permission check.
+ *
+ * @see {@link ServerSecurityProvider}
+ * @module alepha.server.security
+ */
+declare const AlephaServerSecurity: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+//#endregion
+export { AlephaServerSecurity, ServerRouteSecure, ServerSecurityProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/security.js

@@ -0,0 +1 @@
+export * from '@alepha/server-security'

package/server/static.d.ts

@@ -1,88 +1,89 @@
-import { Alepha, HookDescriptor, KIND, Logger, OPTIONS } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, Logger } from "alepha";
 import { ServerHandler, ServerRouterProvider } from "alepha/server";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$serve.d.ts
-declare const KEY = "SERVE";
+/**
+ * Create a new static file handler.
+ */
+declare const $serve: {
+  (options?: ServeDescriptorOptions): ServeDescriptor;
+  [KIND]: typeof ServeDescriptor;
+};
 interface ServeDescriptorOptions {
   /**
-  * Prefix for the served path.
-  *
-  * @default "/"
-  */
+   * Prefix for the served path.
+   *
+   * @default "/"
+   */
   path?: string;
   /**
-  * Path to the directory to serve.
-  *
-  * @default process.cwd()
-  */
+   * Path to the directory to serve.
+   *
+   * @default process.cwd()
+   */
   root?: string;
   /**
-  * If true, descriptor will be ignored.
-  *
-  * @default false
-  */
+   * If true, descriptor will be ignored.
+   *
+   * @default false
+   */
   disabled?: boolean;
   /**
-  * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
-  *
-  * @default true
-  */
+   * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
+   *
+   * @default true
+   */
   ignoreDotEnvFiles?: boolean;
   /**
-  * Whether to use the index.html file when the path is a directory.
-  *
-  * @default true
-  */
+   * Whether to use the index.html file when the path is a directory.
+   *
+   * @default true
+   */
   indexFallback?: boolean;
   /**
-  * Force all requests "not found" to be served with the index.html file.
-  * This is useful for single-page applications (SPAs) that use client-side only routing.
-  */
+   * Force all requests "not found" to be served with the index.html file.
+   * This is useful for single-page applications (SPAs) that use client-side only routing.
+   */
   historyApiFallback?: boolean;
   /**
-  * Optional name of the descriptor.
-  * This is used for logging and debugging purposes.
-  *
-  * @default Key name.
-  */
+   * Optional name of the descriptor.
+   * This is used for logging and debugging purposes.
+   *
+   * @default Key name.
+   */
   name?: string;
   /**
-  * Whether to use cache control headers.
-  *
-  * @default {}
-  */
+   * Whether to use cache control headers.
+   *
+   * @default {}
+   */
   cacheControl?: Partial<CacheControlOptions> | false;
 }
 interface CacheControlOptions {
   /**
-  * Whether to use cache control headers.
-  *
-  * @default [.js, .css]
-  */
+   * Whether to use cache control headers.
+   *
+   * @default [.js, .css]
+   */
   fileTypes: string[];
   /**
-  * The maximum age of the cache in seconds.
-  *
-  * @default 60 * 60 * 24 * 2 // 2 days
-  */
+   * The maximum age of the cache in seconds.
+   *
+   * @default 60 * 60 * 24 * 2 // 2 days
+   */
   maxAge: DurationLike;
   /**
-  * Whether to use immutable cache control headers.
-  *
-  * @default true
-  */
+   * Whether to use immutable cache control headers.
+   *
+   * @default true
+   */
   immutable: boolean;
 }
-interface ServeDescriptor {
-  [KIND]: typeof KEY;
-  [OPTIONS]: ServeDescriptorOptions;
-  list(): string[];
-}
-declare const $serve: {
-  (options?: ServeDescriptorOptions): ServeDescriptor;
-  [KIND]: string;
-};
+declare class ServeDescriptor extends Descriptor<ServeDescriptorOptions> {}
+//# sourceMappingURL=$serve.d.ts.map
 //#endregion
 //#region src/providers/ServerStaticProvider.d.ts
 declare class ServerStaticProvider {
@@ -91,9 +92,8 @@ declare class ServerStaticProvider {
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly log: Logger;
   protected readonly directories: ServeDirectory[];
-  protected readonly configure: HookDescriptor<"configure">;
-  list(name: string): string[];
-  serve(options: ServeDescriptorOptions): Promise<void>;
+  protected readonly configure: _alepha_core0$1.HookDescriptor<"configure">;
+  createStaticServer(options: ServeDescriptorOptions): Promise<void>;
   createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
   protected getCacheFileTypes(): string[];
   protected getCacheControl(filename: string, options: ServeDescriptorOptions): {
@@ -106,19 +106,18 @@ interface ServeDirectory {
   options: ServeDescriptorOptions;
   files: string[];
 }
+//# sourceMappingURL=ServerStaticProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Alepha Server Static Module
-*
-* @see {@link ServerStaticProvider}
-* @module alepha.server.static
-*/
-declare class AlephaServerStatic {
-  readonly name = "alepha.server.static";
-  readonly $services: (alepha: Alepha) => void;
-}
+ * Create static file server with `$static()`.
+ *
+ * @see {@link ServerStaticProvider}
+ * @module alepha.server.static
+ */
+declare const AlephaServerStatic: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $serve, AlephaServerStatic, CacheControlOptions, ServeDescriptor, ServeDescriptorOptions, ServeDirectory, ServerStaticProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/swagger.d.ts

@@ -1,18 +1,27 @@
-import { Alepha, HookDescriptor, KIND, Module, OPTIONS, TObject } from "alepha";
-import { ServerActionDescriptorProvider, ServerRouteAction, ServerRouterProvider } from "alepha/server";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Descriptor, KIND, TObject } from "alepha";
+import { ActionDescriptor, RequestConfigSchema, ServerRouterProvider } from "alepha/server";
 import { ServerStaticProvider } from "alepha/server/static";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/descriptors/$swagger.d.ts
+/**
+ * Create a new OpenAPI.
+ */
+declare const $swagger: {
+  (options: SwaggerDescriptorOptions): SwaggerDescriptor;
+  [KIND]: typeof SwaggerDescriptor;
+};
 interface SwaggerDescriptorOptions {
   info: OpenAPIV3.InfoObject;
   /**
-  * @default: "/docs"
-  */
+   * @default: "/docs"
+   */
   prefix?: string;
   /**
-  * If true, docs will be disabled.
-  */
+   * If true, docs will be disabled.
+   */
   disabled?: boolean;
   excludeTags?: string[];
   ui?: boolean | SwaggerUiOptions;
@@ -22,101 +31,104 @@ interface SwaggerUiOptions {
   root?: string;
   initOAuth?: {
     /**
-    * Default clientId.
-    */
+     * Default clientId.
+     */
     clientId?: string;
     /**
-    * realm query parameter (for oauth1) added to authorizationUrl and tokenUrl.
-    */
+     * realm query parameter (for oauth1) added to authorizationUrl and tokenUrl.
+     */
     realm?: string;
     /**
-    * application name, displayed in authorization popup.
-    */
+     * application name, displayed in authorization popup.
+     */
     appName?: string;
     /**
-    * scope separator for passing scopes, encoded before calling, default
-    * value is a space (encoded value %20).
-    *
-    * @default ' '
-    */
+     * scope separator for passing scopes, encoded before calling, default
+     * value is a space (encoded value %20).
+     *
+     * @default ' '
+     */
     scopeSeparator?: string;
     /**
-    * string array or scope separator (i.e. space) separated string of
-    * initially selected oauth scopes
-    *
-    * @default []
-    */
+     * string array or scope separator (i.e. space) separated string of
+     * initially selected oauth scopes
+     *
+     * @default []
+     */
     scopes?: string | string[];
     /**
-    * Additional query parameters added to authorizationUrl and tokenUrl.
-    * MUST be an object
-    */
+     * Additional query parameters added to authorizationUrl and tokenUrl.
+     * MUST be an object
+     */
     additionalQueryStringParams?: {
       [key: string]: any;
     };
     /**
-    * Only activated for the accessCode flow. During the authorization_code
-    * request to the tokenUrl, pass the Client Password using the HTTP Basic
-    * Authentication scheme (Authorization header with Basic
-    * base64encode(client_id + client_secret)).
-    *
-    * @default false
-    */
+     * Only activated for the accessCode flow. During the authorization_code
+     * request to the tokenUrl, pass the Client Password using the HTTP Basic
+     * Authentication scheme (Authorization header with Basic
+     * base64encode(client_id + client_secret)).
+     *
+     * @default false
+     */
     useBasicAuthenticationWithAccessCodeGrant?: boolean;
     /**
-    * Only applies to Authorization Code flows. Proof Key for Code Exchange
-    * brings enhanced security for OAuth public clients.
-    *
-    * @default false
-    */
+     * Only applies to Authorization Code flows. Proof Key for Code Exchange
+     * brings enhanced security for OAuth public clients.
+     *
+     * @default false
+     */
     usePkceWithAuthorizationCodeGrant?: boolean;
   };
 }
-interface SwaggerDescriptor {
-  [KIND]: "SWAGGER";
-  [OPTIONS]: SwaggerDescriptorOptions;
-  json(): OpenAPIV3.Document;
-}
-declare const $swagger: {
-  (options: SwaggerDescriptorOptions): SwaggerDescriptor;
-  [KIND]: string;
-};
+declare class SwaggerDescriptor extends Descriptor<SwaggerDescriptorOptions> {}
+//# sourceMappingURL=$swagger.d.ts.map
 //#endregion
 //#region src/ServerSwaggerProvider.d.ts
 declare class ServerSwaggerProvider {
-  protected readonly serverActionProvider: ServerActionDescriptorProvider;
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
   protected readonly alepha: Alepha;
-  protected readonly configure: HookDescriptor<"configure">;
-  protected configureOpenApi(doc: SwaggerDescriptorOptions): OpenAPIV3.Document;
+  json?: OpenAPIV3.Document;
+  protected readonly configure: _alepha_core0$1.HookDescriptor<"configure">;
+  createSwagger(options: SwaggerDescriptorOptions): Promise<OpenAPIV3.Document | undefined>;
+  protected configureOpenApi(actions: ActionDescriptor<RequestConfigSchema>[], doc: SwaggerDescriptorOptions): OpenAPIV3.Document;
   isBodyMultipart(schema: TObject): boolean;
   replacePathParams(url: string): string;
-  getResponseSchema(route: ServerRouteAction): {
+  getResponseSchema(route: ActionDescriptor<RequestConfigSchema>): {
     type?: string;
     schema?: any;
     status: number;
   } | undefined;
-  protected configureSwaggerApi(prefix: string, json: OpenAPIV3.Document): Promise<void>;
+  protected configureSwaggerApi(prefix: string, json: OpenAPIV3.Document): void;
   protected configureSwaggerUi(prefix: string, options: SwaggerDescriptorOptions): Promise<void>;
 }
+//# sourceMappingURL=ServerSwaggerProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
-/**
-* Alepha Server Swagger Module
-*
-* Plugin for Alepha Server that provides Swagger documentation capabilities.
-* It generates OpenAPI v3 documentation for the server's endpoints ($action).
-* It also provides a Swagger UI for interactive API documentation.
-*
-* @see {@link ServerSwaggerProvider}
-* @module alepha.server.swagger
-*/
-declare class AlephaServerSwagger implements Module {
-  readonly name = "alepha.server.swagger";
-  readonly $services: (alepha: Alepha) => Alepha;
+declare module "alepha/server" {
+  interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> {
+    /**
+     * Short description of the route.
+     */
+    summary?: string;
+    /**
+     * Don't include this action in the Swagger documentation.
+     */
+    hide?: boolean;
+  }
 }
+/**
+ * Plugin for Alepha Server that provides Swagger documentation capabilities.
+ * It generates OpenAPI v3 documentation for the server's endpoints ($action).
+ * It also provides a Swagger UI for interactive API documentation.
+ *
+ * @see {@link ServerSwaggerProvider}
+ * @module alepha.server.swagger
+ */
+declare const AlephaServerSwagger: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $swagger, AlephaServerSwagger, ServerSwaggerProvider, SwaggerDescriptor, SwaggerDescriptorOptions, SwaggerUiOptions };
 //# sourceMappingURL=index.d.ts.map