@adonisjs/http-server 7.0.0-0 → 7.0.0-2

package/build/src/router/group.d.ts

@@ -0,0 +1,65 @@
+import Macroable from '@poppinss/macroable';
+import type { RouteMatcher } from '../types/route.js';
+import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js';
+import { Route } from './route.js';
+import { BriskRoute } from './brisk.js';
+import { RouteResource } from './resource.js';
+import { OneOrMore } from '../types/base.js';
+/**
+ * Group class exposes the API to take action on a group of routes.
+ * The group routes must be pre-defined using the constructor.
+ */
+export declare class RouteGroup extends Macroable {
+    #private;
+    routes: (Route | RouteGroup | RouteResource | BriskRoute)[];
+    constructor(routes: (Route | RouteGroup | RouteResource | BriskRoute)[]);
+    /**
+     * Define route param matcher
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).where('id', /^[0-9]+/)
+     * ```
+     */
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    /**
+     * Define prefix all the routes in the group.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).prefix('v1')
+     * ```
+     */
+    prefix(prefix: string): this;
+    /**
+     * Define domain for all the routes.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).domain(':name.adonisjs.com')
+     * ```
+     */
+    domain(domain: string): this;
+    /**
+     * Prepend name to the routes name.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).as('version1')
+     * ```
+     */
+    as(name: string): this;
+    /**
+     * Prepend an array of middleware to all routes middleware.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).use(middleware.auth())
+     * ```
+     */
+    use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    /**
+     * @alias use
+     */
+    middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+}

package/build/src/router/lookup_store/main.d.ts

@@ -0,0 +1,47 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Qs } from '../../qs.js';
+import { UrlBuilder } from './url_builder.js';
+import type { RouteJSON } from '../../types/route.js';
+/**
+ * Lookup store exposes the API to lookup routes and
+ * make URLs for registered routes.
+ */
+export declare class LookupStore {
+    #private;
+    constructor(encryption: Encryption, qsParser: Qs);
+    /**
+     * Register route JSON payload
+     */
+    register(route: RouteJSON): void;
+    /**
+     * Returns an instance of the URL builder for making
+     * route URIs
+     */
+    builder(): UrlBuilder;
+    /**
+     * Returns an instance of the URL builder for a specific
+     * domain.
+     */
+    builderForDomain(domain: string): UrlBuilder;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     */
+    find(routeIdentifier: string, domain?: string): RouteJSON | null;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * An error is raised when unable to find the route.
+     */
+    findOrFail(routeIdentifier: string, domain?: string): RouteJSON;
+    /**
+     * Check if a route exists. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     */
+    has(routeIdentifier: string, domain?: string): boolean;
+    toJSON(): Record<string, RouteJSON[]>;
+}

package/build/src/router/lookup_store/route_finder.d.ts

@@ -0,0 +1,25 @@
+import type { RouteJSON } from '../../types/route.js';
+/**
+ * Route finder is used to find a route by its name, route pattern
+ * or the controller.method name.
+ */
+export declare class RouteFinder {
+    #private;
+    register(route: RouteJSON): void;
+    /**
+     * Find a route by indentifier
+     */
+    find(routeIdentifier: string): RouteJSON | null;
+    /**
+     * Find a route by indentifier or fail
+     */
+    findOrFail(routeIdentifier: string): RouteJSON;
+    /**
+     * Find if a route exists
+     */
+    has(routeIdentifier: string): boolean;
+    /**
+     * Returns an array of registered routes
+     */
+    toJSON(): RouteJSON[];
+}

package/build/src/router/lookup_store/url_builder.d.ts

@@ -0,0 +1,52 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Qs } from '../../qs.js';
+import type { RouteFinder } from './route_finder.js';
+/**
+ * URL builder class is used to create URIs for pre-registered
+ * routes.
+ *
+ * ```ts
+ * const builder = new UrlBuilder(encryption, routeFinder)
+ *
+ * builder
+ *  .qs({ sort: 'id' })
+ *  .params([category.id])
+ *  .make('categories.posts.index')
+ * ```
+ */
+export declare class UrlBuilder {
+    #private;
+    constructor(encryption: Encryption, routeFinder: RouteFinder, qsParser: Qs);
+    /**
+     * Prefix a custom base URL to the final URI
+     */
+    prefixUrl(url: string): this;
+    /**
+     * Disable route lookup. Calling this method considers
+     * the "identifier" as the route pattern
+     */
+    disableRouteLookup(): this;
+    /**
+     * Append query string to the final URI
+     */
+    qs(queryString?: Record<string, any>): this;
+    /**
+     * Specify params to apply to the route pattern
+     */
+    params(params?: any[] | Record<string, any>): this;
+    /**
+     * Generate URL for the given route identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     */
+    make(identifier: string): string;
+    /**
+     * Generate a signed URL for the given route identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     */
+    makeSigned(identifier: string, options?: {
+        expiresIn?: string | number;
+        purpose?: string;
+    }): string;
+}

package/build/src/router/main.d.ts

@@ -0,0 +1,128 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import type { Qs } from '../qs.js';
+import { Route } from './route.js';
+import { RouteGroup } from './group.js';
+import { BriskRoute } from './brisk.js';
+import { RouteResource } from './resource.js';
+import { LookupStore } from './lookup_store/main.js';
+import { RouteMatchers as Matchers } from './matchers.js';
+import type { Constructor, LazyImport } from '../types/base.js';
+import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
+import type { RouteFn, MatchedRoute, RouteMatcher, RouteMatchers, MakeUrlOptions, MakeSignedUrlOptions, GetControllerHandlers } from '../types/route.js';
+/**
+ * Router class exposes a unified API to register new routes, group them or
+ * create route resources.
+ *
+ * ```ts
+ * const router = new Router()
+ *
+ * router.get('/', async function () {
+ *   // handle request
+ * })
+ * ```
+ */
+export declare class Router extends LookupStore {
+    #private;
+    /**
+     * Collection of routes, including route resource and route
+     * group. To get a flat list of routes, call `router.toJSON()`
+     */
+    routes: (Route | RouteResource | RouteGroup | BriskRoute)[];
+    /**
+     * A flag to know if routes for explicit domains have been registered.
+     * The boolean is computed after calling the "commit" method.
+     */
+    usingDomains: boolean;
+    /**
+     * Shortcut methods for commonly used route matchers
+     */
+    matchers: Matchers;
+    constructor(app: Application<any>, encryption: Encryption, qsParser: Qs);
+    /**
+     * Parses the route pattern
+     */
+    parsePattern(pattern: string, matchers?: RouteMatchers): import("../types/route.js").MatchItRouteToken[];
+    /**
+     * Define an array of middleware to use on all the routes.
+     * Calling this method multiple times pushes to the
+     * existing list of middleware
+     */
+    use(middleware: LazyImport<MiddlewareAsClass>[]): this;
+    /**
+     * Define a collection of named middleware. The defined collection is
+     * not registered anywhere, but instead converted in a new collection
+     * of functions you can apply on the routes, or router groups.
+     */
+    named<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends import("../types/middleware.js").GetMiddlewareArgs<import("../types/base.js").UnWrapLazyImport<NamedMiddleware[K]>>>(...args: Args) => {
+        name: K;
+        args: Args[0];
+    } & ParsedGlobalMiddleware; };
+    /**
+     * Add route for a given pattern and methods
+     */
+    route<T extends Constructor<any>>(pattern: string, methods: string[], handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Define a route that handles all common HTTP methods
+     */
+    any<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Define `GET` route
+     */
+    get<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Define `POST` route
+     */
+    post<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Define `PUT` route
+     */
+    put<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Define `PATCH` route
+     */
+    patch<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Define `DELETE` route
+     */
+    delete<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    /**
+     * Creates a group of routes. A route group can apply transforms
+     * to routes in bulk
+     */
+    group(callback: () => void): RouteGroup;
+    /**
+     * Registers a route resource with conventional set of routes
+     */
+    resource(resource: string, controller: string | LazyImport<Constructor<any>> | Constructor<any>): RouteResource<import("../types/route.js").ResourceActionNames>;
+    /**
+     * Register a route resource with shallow nested routes.
+     */
+    shallowResource(resource: string, controller: string | LazyImport<Constructor<any>> | Constructor<any>): RouteResource<import("../types/route.js").ResourceActionNames>;
+    /**
+     * Returns a brisk route instance for a given URL pattern
+     */
+    on(pattern: string): BriskRoute;
+    /**
+     * Define matcher for a given param. The global params are applied
+     * on all the routes (unless overridden at the route level).
+     */
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    /**
+     * Commit routes to the store. The router is freezed after the
+     * commit method is called.
+     */
+    commit(): void;
+    /**
+     * Find route for a given URL, method and optionally domain
+     */
+    match(url: string, method: string, hostname?: string | null): null | MatchedRoute;
+    /**
+     * Make URL to a pre-registered route
+     */
+    makeUrl(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): string;
+    /**
+     * Makes a signed URL to a pre-registered route.
+     */
+    makeSignedUrl(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeSignedUrlOptions): string;
+}

package/build/src/router/matchers.d.ts

@@ -0,0 +1,27 @@
+import Macroable from '@poppinss/macroable';
+/**
+ * Shortcut methods for commonly used route matchers
+ */
+export declare class RouteMatchers extends Macroable {
+    /**
+     * Enforce value to be a number and also casts it to number data
+     * type
+     */
+    number(): {
+        match: RegExp;
+        cast: (value: string) => number;
+    };
+    /**
+     * Enforce value to be formatted as uuid
+     */
+    uuid(): {
+        match: RegExp;
+        cast: (value: string) => string;
+    };
+    /**
+     * Enforce value to be formatted as slug
+     */
+    slug(): {
+        match: RegExp;
+    };
+}

package/build/src/router/parser.d.ts

@@ -0,0 +1,5 @@
+import { MatchItRouteToken, RouteMatchers } from '../types/route.js';
+/**
+ * Parses the route pattern
+ */
+export declare function parseRoutePattern(pattern: string, matchers?: RouteMatchers): MatchItRouteToken[];

package/build/src/router/resource.d.ts

@@ -0,0 +1,66 @@
+import Macroable from '@poppinss/macroable';
+import type { Application } from '@adonisjs/application';
+import { Route } from './route.js';
+import type { Constructor, LazyImport, OneOrMore } from '../types/base.js';
+import type { MiddlewareFn, ParsedGlobalMiddleware, ParsedNamedMiddleware } from '../types/middleware.js';
+import type { ResourceActionNames, RouteMatcher, RouteMatchers } from '../types/route.js';
+/**
+ * Route resource exposes the API to register multiple routes for a resource.
+ */
+export declare class RouteResource<ActionNames extends ResourceActionNames = ResourceActionNames> extends Macroable {
+    #private;
+    /**
+     * A collection of routes instances that belongs to this resource
+     */
+    routes: Route[];
+    constructor(app: Application<any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
+        resource: string;
+        controller: string | LazyImport<Constructor<any>> | Constructor<any>;
+        globalMatchers: RouteMatchers;
+        shallow: boolean;
+    });
+    /**
+     * Register only given routes and remove others
+     */
+    only<Name extends ActionNames>(names: Name[]): RouteResource<Name>;
+    /**
+     * Register all routes, except the one's defined
+     */
+    except<Name extends ActionNames>(names: Name[]): RouteResource<Exclude<ActionNames, Name>>;
+    /**
+     * Register api only routes. The `create` and `edit` routes, which
+     * are meant to show forms will not be registered
+     */
+    apiOnly(): RouteResource<Exclude<ActionNames, 'create' | 'edit'>>;
+    /**
+     * Define matcher for params inside the resource
+     */
+    where(key: string, matcher: RouteMatcher | string | RegExp): this;
+    /**
+     * Tap into multiple routes to configure them by their name
+     */
+    tap(callback: (route: Route) => void): this;
+    tap(actions: ActionNames | ActionNames[], callback: (route: Route) => void): this;
+    /**
+     * Set the param name for a given resource
+     */
+    params(resources: {
+        [resource: string]: string;
+    }): this;
+    /**
+     * Define one or more middleware on the routes created by
+     * the resource.
+     *
+     * Calling this method multiple times will append middleware
+     * to existing list.
+     */
+    use(actions: ActionNames | ActionNames[] | '*', middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    /**
+     * @alias use
+     */
+    middleware(actions: ActionNames | ActionNames[] | '*', middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    /**
+     * Prepend name to all the routes
+     */
+    as(name: string, normalizeName?: boolean): this;
+}

package/build/src/router/route.d.ts

@@ -0,0 +1,92 @@
+import Macroable from '@poppinss/macroable';
+import type { Application } from '@adonisjs/application';
+import type { Constructor, LazyImport, OneOrMore } from '../types/base.js';
+import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.js';
+import type { GetControllerHandlers, RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware } from '../types/route.js';
+/**
+ * The route class exposes the APIs for constructing a route using the
+ * fluent API.
+ */
+export declare class Route<Controller extends Constructor<any> = any> extends Macroable {
+    #private;
+    constructor(app: Application<any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
+        pattern: string;
+        methods: string[];
+        handler: RouteFn | string | [LazyImport<Controller> | Controller, GetControllerHandlers<Controller>?];
+        globalMatchers: RouteMatchers;
+    });
+    /**
+     * Define matcher for a given param. If a matcher exists, then we do not
+     * override that, since the routes inside a group will set matchers
+     * before the group, so they should have priority over the group
+     * matchers.
+     *
+     * ```ts
+     * Route.group(() => {
+     *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
+     * }).where('id', /[^a-z$]/)
+     * ```
+     *
+     * The `/^[0-9]$/` will win over the matcher defined by the group
+     */
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    /**
+     * Define prefix for the route. Calling this method multiple times
+     * applies multiple prefixes in the reverse order.
+     */
+    prefix(prefix: string): this;
+    /**
+     * Define a custom domain for the route. We do not overwrite the domain
+     * unless `overwrite` flag is set to true.
+     */
+    domain(domain: string, overwrite?: boolean): this;
+    /**
+     * Define one or more middleware to be executed before the route
+     * handler.
+     *
+     * Named middleware can be referenced using the name registered with
+     * the router middleware store.
+     */
+    use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    /**
+     * @alias use
+     */
+    middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    /**
+     * Give a unique name to the route. Assinging a new unique removes the
+     * existing name of the route.
+     *
+     * Setting prepends to true prefixes the name to the existing name.
+     */
+    as(name: string, prepend?: boolean): this;
+    /**
+     * Check if the route was marked to be deleted
+     */
+    isDeleted(): boolean;
+    /**
+     * Mark route as deleted. Deleted routes are not registered
+     * with the route store
+     */
+    markAsDeleted(): void;
+    /**
+     * Get the route name
+     */
+    getName(): string | undefined;
+    /**
+     * Get the route pattern
+     */
+    getPattern(): string;
+    /**
+     * Set the route pattern
+     */
+    setPattern(pattern: string): this;
+    /**
+     * Returns the stack of middleware registered on the route.
+     * The value is shared by reference.
+     */
+    getMiddleware(): StoreRouteMiddleware[][];
+    /**
+     * Returns JSON representation of the route
+     */
+    toJSON(): RouteJSON;
+}

package/build/src/router/store.d.ts

@@ -0,0 +1,66 @@
+import type { RouteJSON, MatchedRoute, StoreRoutesTree, MatchItRouteToken } from '../types/route.js';
+/**
+ * Store class is used to store a list of routes, along side with their tokens
+ * to match the URLs.
+ *
+ * ```ts
+ * const store = new Store()
+ *
+ * store.add({
+ *  pattern: 'posts/:id',
+ *  handler: function onRoute () {},
+ *  middleware: [],
+ *  matchers: {
+ *    id: '^[0-9]$+'
+ *  },
+ *  meta: {},
+ *  methods: ['GET']
+ * })
+ *
+ * store.match('posts/1', 'GET')
+ * ```
+ */
+export declare class RoutesStore {
+    #private;
+    /**
+     * A flag to know if routes for explicit domains
+     * have been registered
+     */
+    usingDomains: boolean;
+    /**
+     * Tree of registered routes and their matchit tokens
+     */
+    tree: StoreRoutesTree;
+    /**
+     * Add a route to the store
+     *
+     * ```ts
+     * store.add({
+     *   pattern: 'post/:id',
+     *   methods: ['GET'],
+     *   matchers: {},
+     *   meta: {},
+     *   handler: function handler () {
+     *   }
+     * })
+     * ```
+     */
+    add(route: RouteJSON): this;
+    /**
+     * Matches the url, method and optionally domain to pull the matching
+     * route. `null` is returned when unable to match the URL against
+     * registered routes.
+     *
+     * The domain parameter has to be a registered pattern and not the fully
+     * qualified runtime domain. You must call `matchDomain` first to fetch
+     * the pattern for qualified domain
+     */
+    match(url: string, method: string, domain?: {
+        tokens: MatchItRouteToken[];
+        hostname: string;
+    }): null | MatchedRoute;
+    /**
+     * Match hostname against registered domains.
+     */
+    matchDomain(hostname?: string | null): MatchItRouteToken[];
+}

package/build/src/server/factories/final_handler.d.ts

@@ -0,0 +1,10 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { Router } from '../../router/main.js';
+import type { HttpContext } from '../../http_context/main.js';
+import type { ServerErrorHandler } from '../../types/server.js';
+/**
+ * The final handler is executed after the server middleware stack.
+ * It looks for a matching route and executes the route middleware
+ * stack.
+ */
+export declare function finalHandler(router: Router, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']): () => any;

package/build/src/server/factories/middleware_handler.d.ts

@@ -0,0 +1,8 @@
+import type { NextFn } from '@poppinss/middleware/types';
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { HttpContext } from '../../http_context/main.js';
+import { ParsedGlobalMiddleware } from '../../types/middleware.js';
+/**
+ * The middleware handler invokes the middleware functions.
+ */
+export declare function middlewareHandler(resolver: ContainerResolver<any>, ctx: HttpContext): (fn: ParsedGlobalMiddleware, next: NextFn) => any;

package/build/src/server/factories/write_response.d.ts

@@ -0,0 +1,6 @@
+import type { HttpContext } from '../../http_context/main.js';
+/**
+ * Writes the response to the socket. The "finish" method can
+ * raise error when unable to serialize the response.
+ */
+export declare function writeResponse(ctx: HttpContext): () => void;

package/build/{main-29eaaee4.d.ts → src/server/main.d.ts}

@@ -1,17 +1,24 @@
-import { Logger } from '@adonisjs/logger';
-import { Emitter } from '@adonisjs/events';
-import { Encryption } from '@adonisjs/encryption';
-import { Server as Server$2 } from 'node:https';
-import { Application } from '@adonisjs/application';
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Logger } from '@adonisjs/logger';
+import type { Emitter } from '@adonisjs/events';
+import type { Encryption } from '@adonisjs/encryption';
+import type { Server as HttpsServer } from 'node:https';
+import type { Application } from '@adonisjs/application';
 import { ContainerResolver } from '@adonisjs/fold';
-import { Server as Server$1, IncomingMessage, ServerResponse } from 'node:http';
-import { S as ServerConfig, M as MiddlewareAsClass, T as TestingMiddlewarePipeline, L as LazyImport, E as ErrorHandlerAsAClass, R as Router, a as Request, b as Response, H as HttpContext } from './main-e5b46c83.js';
-
+import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http';
+import type { LazyImport } from '../types/base.js';
+import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { ServerConfig, ErrorHandlerAsAClass, TestingMiddlewarePipeline } from '../types/server.js';
+import { Request } from '../request.js';
+import { Response } from '../response.js';
+import { Router } from '../router/main.js';
+import { HttpContext } from '../http_context/main.js';
 /**
  * The HTTP server implementation to handle incoming requests and respond using the
  * registered routes.
  */
-declare class Server {
+export declare class Server {
     #private;
     /**
      * Know if async local storage is enabled or not.
@@ -43,12 +50,12 @@ declare class Server {
     /**
      * Set the HTTP server instance used to listen for requests.
      */
-    setNodeServer(server: Server$1 | Server$2): void;
+    setNodeServer(server: HttpServer | HttpsServer): void;
     /**
      * Returns reference to the underlying HTTP server
      * in use
      */
-    getNodeServer(): Server$1<typeof IncomingMessage, typeof ServerResponse> | Server$2<typeof IncomingMessage, typeof ServerResponse> | undefined;
+    getNodeServer(): HttpServer<typeof IncomingMessage, typeof ServerResponse> | HttpsServer<typeof IncomingMessage, typeof ServerResponse> | undefined;
     /**
      * Returns reference to the router instance used
      * by the server.
@@ -71,5 +78,3 @@ declare class Server {
      */
     handle(req: IncomingMessage, res: ServerResponse): Promise<any>;
 }
-
-export { Server as S };