@vercube/core 0.0.2 → 0.0.4

package/dist/index.d.mts

@@ -0,0 +1,1193 @@
+import { Container } from "@vercube/di";
+import { FastResponse } from "srvx";
+import { LoggerTypes } from "@vercube/logger";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/Services/Plugins/BasePlugin.d.ts
+/**
+ * Represents a Plugin.
+ */
+declare class BasePlugin<T = unknown> {
+  /**
+   * The name of the plugin.
+   */
+  name: string;
+  /**
+   * Uses the plugin with the given app.
+   * @param {App} app - The application instance.
+   * @returns {void | Promise<void>} - A void or a promise that resolves to void.
+   */
+  use(app: App, options?: T): void | Promise<void>;
+}
+//#endregion
+//#region src/Types/ConfigTypes.d.ts
+/**
+ * Namespace containing configuration type definitions for the Vercube framework.
+ */
+declare namespace ConfigTypes {
+  /**
+   * Runtime configuration interface that can be modified during application execution.
+   */
+  interface RuntimeConfig {
+    /**
+     * Session configuration options.
+     */
+    session?: {
+      /**
+       * The secret used to sign the session ID cookie.
+       */
+      secret?: string;
+      /**
+       * The name of the session ID cookie.
+       */
+      name?: string;
+      /**
+       * The duration of time for the session to be active.
+       */
+      duration?: number;
+    };
+  }
+  /**
+   * Configuration options for experimental features.
+   * These options may change or be removed in future versions.
+   */
+  interface ExperimentalOptions {}
+  /**
+   * Build configuration options for the application.
+   */
+  interface BuildOptions {
+    /**
+     * The root directory for the application.
+     */
+    root?: string;
+    /**
+     * The entry point file for the application build.
+     */
+    entry?: string;
+    /**
+     * Defines to pass to the build.
+     */
+    define?: Record<string, string>;
+    /**
+     * Output configuration for build artifacts.
+     */
+    output?: {
+      /**
+       * The main output directory for build artifacts.
+       */
+      dir?: string;
+      /**
+       * The directory for public/client-side build artifacts.
+       */
+      publicDir?: string;
+    };
+    /**
+     * The bundler to use for the application build.
+     */
+    bundler?: 'rolldown';
+  }
+  /**
+   * Server configuration options for the application.
+   */
+  interface ServerOptions {
+    /**
+     * The runtime environment for the application.
+     */
+    runtime?: 'node' | 'bun' | 'deno';
+    /**
+     * The hostname to bind the server to.
+     */
+    host?: string;
+    /**
+     * The port number to listen on.
+     */
+    port?: number;
+    /**
+     * HTTPS configuration options.
+     */
+    https?: false | {
+      /**
+       * Path to the SSL key file.
+       */
+      key: string;
+      /**
+       * Path to the SSL certificate file.
+       */
+      cert: string;
+    };
+    /**
+     * Static server options
+     */
+    static?: {
+      dirs: string[];
+      maxAge?: number;
+      immutable?: boolean;
+      etag?: boolean;
+    };
+  }
+  /**
+   * Main configuration interface for the Vercube application.
+   */
+  interface Config {
+    /**
+     * Flag indicating if the application is running in production mode.
+     */
+    production?: boolean;
+    /**
+     * Flag indicating if the application is running in development mode.
+     */
+    dev?: boolean;
+    /**
+     * The logging level for the application.
+     */
+    logLevel?: LoggerTypes.Level;
+    /**
+     * Server configuration options.
+     */
+    server?: ServerOptions;
+    /**
+     * Runtime configuration for the application.
+     */
+    runtime?: RuntimeConfig;
+    /**
+     * Experimental features configuration.
+     */
+    experimental?: ExperimentalOptions;
+    /**
+     * Build configuration options.
+     * This property is only used when using vercube cli.
+     */
+    build?: BuildOptions;
+  }
+}
+//#endregion
+//#region src/Common/App.d.ts
+/**
+ * Represents the main application class.
+ */
+declare class App {
+  private gRouter;
+  private gPluginsRegistry;
+  private gHttpServer;
+  private gStaticRequestHandler;
+  private gLogger;
+  /** Holds the initialization status of the application */
+  private fIsInitialized;
+  /** Holds the dependency injection container */
+  private fInternalContainer;
+  /** Hold app config */
+  private fConfig;
+  /**
+   * Gets the dependency injection container.
+   *
+   * @returns {Container} The dependency injection container.
+   */
+  get container(): Container;
+  /**
+   * Sets the dependency injection container.
+   *
+   * @param {Container} container - The dependency injection container.
+   */
+  set container(container: Container);
+  /**
+   * Initializes the application.
+   *
+   * @returns {Promise<void>} A promise that resolves when the application is initialized.
+   */
+  init(cfg: ConfigTypes.Config): Promise<void>;
+  /**
+   * Registers a plugin.
+   *
+   * @param {typeof Plugin} plugin - The plugin to register.
+   * @param {unknown} options - The options to pass to the plugin.
+   */
+  registerPlugin<T>(plugin: typeof BasePlugin<T>, options?: T): void;
+  /**
+   * Starts the application and begins listening for incoming requests.
+   *
+   * @returns {Promise<void>} A promise that resolves when the application starts listening.
+   * @throws {Error} If the application is already initialized.
+   */
+  listen(): Promise<void>;
+  /**
+   * Handles an incoming HTTP request.
+   * This method is an adapter for HttpServer.handleRequest method.
+   *
+   * @param {Request} request - The incoming HTTP request
+   * @returns {Promise<Response>} The HTTP response
+   */
+  fetch(request: Request): Promise<Response>;
+  /**
+   * Resolves and initializes the plugins for the application.
+   *
+   * @private
+   */
+  private resolvePlugins;
+}
+//#endregion
+//#region src/Common/CreateApp.d.ts
+/**
+ * Creates and initializes an instance of the App.
+ *
+ * @returns {Promise<App>} A promise that resolves to an instance of the App.
+ */
+declare function createApp(cfg?: ConfigTypes.Config): Promise<App>;
+//#endregion
+//#region src/Config/Config.d.ts
+/**
+ * Defines a configuration object for the application
+ * @param {ConfigTypes.Config} config - The configuration object to validate
+ * @returns {ConfigTypes.Config} The validated configuration object
+ */
+declare function defineConfig(config: ConfigTypes.Config): ConfigTypes.Config;
+//#endregion
+//#region src/Config/Loader.d.ts
+/**
+ * Loads the configuration object for the application
+ * @param {ConfigTypes.Config} overrides - The configuration object to load
+ * @returns {ConfigTypes.Config} The loaded configuration object
+ */
+declare function loadVercubeConfig(overrides?: ConfigTypes.Config): Promise<ConfigTypes.Config>;
+//#endregion
+//#region src/Types/ValidationTypes.d.ts
+declare namespace ValidationTypes {
+  type Schema = StandardSchemaV1;
+  type Result<T = any> = StandardSchemaV1.Result<T>;
+  type Input<T extends Schema = Schema> = StandardSchemaV1.InferInput<T>;
+}
+//#endregion
+//#region src/Decorators/Http/Body.d.ts
+interface BodyDecoratorOptions {
+  validationSchema?: ValidationTypes.Schema;
+}
+/**
+ * @function Body
+ * @returns {Function} A decorator function that registers the BodyDecorator.
+ *
+ * This function creates and returns a decorator that can be used to annotate
+ * a parameter in a method to indicate that it should be populated with the
+ * body of an HTTP request. The decorator uses the BodyDecorator class to
+ * handle the metadata associated with the parameter.
+ */
+declare function Body(options?: BodyDecoratorOptions): Function;
+//#endregion
+//#region src/Decorators/Http/Connect.d.ts
+/**
+ * A factory function for creating a ConnectDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with CONNECT route information.
+ *
+ * @param {string} path - The path for the CONNECT route.
+ * @return {Function} The decorator function.
+ */
+declare function Connect(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Controller.d.ts
+/**
+ * A factory function for creating a Controller decorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a class with controller metadata, including the base path for the controller.
+ *
+ * @param {string} path - The base path for the controller.
+ * @return {Function} The decorator function.
+ */
+declare function Controller(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Delete.d.ts
+/**
+ * A factory function for creating a DeleteDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with DELETE route information.
+ *
+ * @param {string} path - The path for the DELETE route.
+ * @return {Function} The decorator function.
+ */
+declare function Delete(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Get.d.ts
+/**
+ * A decorator function for handling HTTP GET requests.
+ *
+ * This function creates an instance of the GetDecorator class and registers
+ * the GET route with the specified path.
+ *
+ * @param {string} path - The path for the GET route.
+ * @returns {Function} - The decorator function.
+ */
+declare function Get(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Head.d.ts
+/**
+ * A factory function for creating a HeadDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with HEAD route information.
+ *
+ * @param {string} path - The path for the HEAD route.
+ * @return {Function} The decorator function.
+ */
+declare function Head(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Header.d.ts
+/**
+ * A decorator function for handling HTTP header parameters.
+ *
+ * This function creates a HeaderDecorator with the specified name and registers it.
+ * It is used to annotate a parameter in a method to indicate that it should be
+ * populated with the value of a specific HTTP header.
+ *
+ * @param {string} name - The name of the HTTP header to bind to the parameter.
+ * @returns {Function} - A decorator function that registers the HeaderDecorator.
+ */
+declare function Header(name: string): Function;
+//#endregion
+//#region src/Decorators/Http/Headers.d.ts
+/**
+ * A factory function for creating a HeadersDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with headers information.
+ *
+ * @return {Function} The decorator function.
+ */
+declare function Headers(): Function;
+//#endregion
+//#region src/Decorators/Http/Options.d.ts
+/**
+ * A factory function for creating an OptionsDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with OPTIONS route information.
+ *
+ * @param {string} path - The path for the OPTIONS route.
+ * @return {Function} The decorator function.
+ */
+declare function Options(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Param.d.ts
+/**
+ * A factory function for creating a ParamDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with parameter information.
+ *
+ * @param {string} name - The name of the parameter.
+ * @param {Object} [opts] - Optional settings for the parameter.
+ * @param {boolean} [opts.decode=false] - Whether to decode the parameter.
+ * @return {Function} The decorator function.
+ */
+declare function Param(name: string): Function;
+//#endregion
+//#region src/Decorators/Http/Patch.d.ts
+/**
+ * A factory function for creating a PatchDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with PATCH route information.
+ *
+ * @param {string} path - The path for the PATCH route.
+ * @return {Function} The decorator function.
+ */
+declare function Patch(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Post.d.ts
+/**
+ * A factory function for creating a PostDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with POST route information.
+ *
+ * @param {string} path - The path for the POST route.
+ * @return {Function} The decorator function.
+ */
+declare function Post(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/Put.d.ts
+/**
+ * A factory function for creating a PutDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with PUT route information.
+ *
+ * @param {string} path - The path for the PUT route.
+ * @return {Function} The decorator function.
+ */
+declare function Put(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/QueryParam.d.ts
+interface QueryParamDecoratorOptions {
+  name: string;
+  validationSchema?: ValidationTypes.Schema;
+}
+/**
+ * A factory function for creating a QueryDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with query parameter information.
+ *
+ * @param {QueryParamDecoratorOptions} options - The options for the decorator.
+ * @return {Function} The decorator function.
+ */
+declare function QueryParam(options: QueryParamDecoratorOptions): Function;
+//#endregion
+//#region src/Decorators/Http/QueryParams.d.ts
+interface QueryParamsDecoratorOptions {
+  validationSchema?: ValidationTypes.Schema;
+}
+/**
+ * A factory function for creating a QueryParamsDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with query parameter information.
+ *
+ * @param {QueryParamsDecoratorOptions} options - The options for the decorator.
+ * @return {Function} The decorator function.
+ */
+declare function QueryParams(options?: QueryParamsDecoratorOptions): Function;
+//#endregion
+//#region src/Decorators/Http/Request.d.ts
+/**
+ * A factory function for creating a RequestDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with request information.
+ *
+ * @return {Function} The decorator function.
+ */
+declare function Request$1(): Function;
+//#endregion
+//#region src/Decorators/Http/Response.d.ts
+/**
+ * A factory function for creating a ResponseDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with response information.
+ *
+ * @return {Function} The decorator function.
+ */
+declare function Response$1(): Function;
+//#endregion
+//#region src/Decorators/Http/Trace.d.ts
+/**
+ * A factory function for creating a TraceDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method with TRACE route information.
+ *
+ * @param {string} path - The path for the TRACE route.
+ * @return {Function} The decorator function.
+ */
+declare function Trace(path: string): Function;
+//#endregion
+//#region src/Decorators/Http/SetHeader.d.ts
+/**
+ * Creates a SetHeader decorator.
+ * @param {string} key - The header key.
+ * @param {string} value - The header value.
+ * @returns {Function} The decorator function.
+ */
+declare function SetHeader(key: string, value: string): Function;
+//#endregion
+//#region src/Types/HttpTypes.d.ts
+declare enum HTTPStatus {
+  CONTINUE = 100,
+  SWITCHING_PROTOCOLS = 101,
+  PROCESSING = 102,
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  MULTI_STATUS = 207,
+  ALREADY_REPORTED = 208,
+  IM_USED = 226,
+  MULTIPLE_CHOICES = 300,
+  MOVED_PERMANENTLY = 301,
+  FOUND = 302,
+  SEE_OTHER = 303,
+  NOT_MODIFIED = 304,
+  USE_PROXY = 305,
+  TEMPORARY_REDIRECT = 307,
+  PERMANENT_REDIRECT = 308,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  PAYMENT_REQUIRED = 402,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  REQUEST_TIMEOUT = 408,
+  CONFLICT = 409,
+  GONE = 410,
+  LENGTH_REQUIRED = 411,
+  PRECONDITION_FAILED = 412,
+  PAYLOAD_TOO_LARGE = 413,
+  URI_TOO_LONG = 414,
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  RANGE_NOT_SATISFIABLE = 416,
+  EXPECTATION_FAILED = 417,
+  I_AM_A_TEAPOT = 418,
+  // Easter egg from RFC 2324
+  MISDIRECTED_REQUEST = 421,
+  UNPROCESSABLE_ENTITY = 422,
+  LOCKED = 423,
+  FAILED_DEPENDENCY = 424,
+  TOO_EARLY = 425,
+  UPGRADE_REQUIRED = 426,
+  PRECONDITION_REQUIRED = 428,
+  TOO_MANY_REQUESTS = 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  VARIANT_ALSO_NEGOTIATES = 506,
+  INSUFFICIENT_STORAGE = 507,
+  LOOP_DETECTED = 508,
+  NOT_EXTENDED = 510,
+  NETWORK_AUTHENTICATION_REQUIRED = 511,
+}
+//#endregion
+//#region src/Decorators/Http/Status.d.ts
+/**
+ * Creates a Status decorator.
+ * @param {number} code - The status value.
+ * @returns {Function} The decorator function.
+ */
+declare function Status(code: HTTPStatus): Function;
+//#endregion
+//#region src/Decorators/Http/Redirect.d.ts
+/**
+ * Creates a Redirect decorator.
+ * @param {string} location - The location header value.
+ * @param {number} [code=301] - The status code.
+ * @returns {Function} The decorator function.
+ */
+declare function Redirect(location: string, code?: HTTPStatus): Function;
+//#endregion
+//#region src/Types/RouterTypes.d.ts
+declare namespace RouterTypes {
+  interface Route {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'CONNECT' | 'TRACE';
+    handler: RouterHandler;
+  }
+  interface RouteFind {
+    path: string;
+    method: string;
+  }
+  interface MiddlewareDefinition {
+    middleware: BaseMiddleware<unknown, unknown>;
+    target: string;
+    priority?: number;
+    args?: unknown;
+  }
+  interface RouterHandler {
+    instance: any;
+    propertyName: string;
+    args: MetadataTypes.Arg[];
+    middlewares: {
+      beforeMiddlewares: MiddlewareDefinition[];
+      afterMiddlewares: MiddlewareDefinition[];
+    };
+    actions: MetadataTypes.Action[];
+  }
+  interface RouteMatched<T = unknown> {
+    data: T;
+    params?: Record<string, string>;
+  }
+  type RouterEvent = RouterTypes.RouteMatched<RouterTypes.RouterHandler> & {
+    request: Request;
+    response: Response;
+  };
+}
+//#endregion
+//#region src/Types/MetadataTypes.d.ts
+declare namespace MetadataTypes {
+  interface Metadata {
+    __metadata: Ctx;
+  }
+  interface Ctx {
+    __controller: {
+      path: string;
+    };
+    __middlewares: Middleware[];
+    __methods: Record<string, Method>;
+  }
+  interface Method {
+    req: Request | null;
+    res: Response | null;
+    url: string | null;
+    args: Arg[];
+    actions: Action[];
+  }
+  interface ResolvedData {
+    req: Request | null;
+    res: Response | null;
+    url: string | null;
+    args: Arg[];
+    actions: Action[];
+    middlewares: Middleware[];
+  }
+  interface Arg {
+    idx: number;
+    type: string;
+    data?: Record<string, any>;
+    resolver?: (event: RouterTypes.RouterEvent) => Promise<unknown>;
+    resolved?: unknown;
+    validate?: boolean;
+    validationSchema?: ValidationTypes.Schema;
+  }
+  interface Action {
+    handler: (req: Request, res: Response) => void | Response | ResponseInit;
+  }
+  interface Middleware<T = unknown, U = unknown> {
+    target: string;
+    priority?: number;
+    middleware: typeof BaseMiddleware<T, U>;
+    args?: unknown;
+  }
+  interface ResolveUrlParams {
+    instance: any;
+    path: string;
+    propertyName: string;
+  }
+}
+//#endregion
+//#region src/Types/CommonTypes.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface MiddlewareOptions<T = any> {
+  middlewareArgs?: T;
+  methodArgs?: MetadataTypes.Arg[];
+}
+//#endregion
+//#region src/Services/Middleware/BaseMiddleware.d.ts
+/**
+ * BaseMiddleware class that serves as a base for all middleware implementations.
+ */
+declare class BaseMiddleware<T = any, U = any> {
+  /**
+   * Middleware function that processes the HTTP event.
+   * This method should be overridden by subclasses to implement specific middleware logic.
+   * WARNING: This method cannot return a value, it will be ignored.
+   * Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
+   *
+   * @param {Request} request - The HTTP Request to process
+   * @param {T[]} args - Additional arguments for the middleware.
+   * @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
+   */
+  onRequest?(request: Request, response: Response, args: MiddlewareOptions<T>): MaybePromise<void | Response>;
+  /**
+   * Middleware function that processes the response.
+   * This method should be overridden by subclasses to implement specific middleware logic.
+   * WARNING: This method cannot return a value, it will be ignored.
+   * Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
+   *
+   * @param {Request} request - The HTTP Request to process
+   * @param {Response} response - The HTTP Response to process
+   * @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
+   */
+  onResponse?(request: Request, response: Response, payload: U): MaybePromise<void | Response>;
+}
+//#endregion
+//#region src/Decorators/Http/Middleware.d.ts
+interface MiddlewareDecoratorParams extends Omit<MetadataTypes.Middleware, 'middleware'> {}
+/**
+ * Decorator that applies middleware to a class or method
+ * @param middleware - The middleware class to apply
+ * @param opts - Optional configuration parameters
+ * @param opts.type - The type of middleware ('before' or 'after')
+ * @param opts.priority - Priority order for middleware execution (default: 999)
+ * @returns A decorator function that can be applied to classes or methods
+ *
+ * @example
+ * ```typescript
+ * @Middleware(AuthMiddleware)
+ * class UserController {
+ *   // ...
+ * }
+ *
+ * // Or on a specific method:
+ * @Middleware(ValidationMiddleware, { type: 'before', priority: 1 })
+ * public async createUser() {
+ *   // ...
+ * }
+ * ```
+ */
+declare function Middleware$1(middleware: typeof BaseMiddleware, opts?: MiddlewareDecoratorParams): Function;
+//#endregion
+//#region src/Decorators/Http/MultipartFormData.d.ts
+/**
+ * Decorator function that marks a parameter as multipart/form-data request body.
+ * This decorator will automatically parse incoming multipart form data
+ *
+ * @decorator
+ * @returns {Function} A decorator function that can be applied to method parameters
+ *
+ * @example
+ * class UserController {
+ *   uploadFile(@MultipartFormData() formData: MyData) {
+ *     // Handle multipart form data
+ *   }
+ * }
+ */
+declare function MultipartFormData(): Function;
+//#endregion
+//#region src/Decorators/Http/Session.d.ts
+/**
+ * A factory function for creating a SessionDecorator.
+ *
+ * This function returns a decorator function that can be used to annotate
+ * a method parameter with session information.
+ *
+ * @return {Function} The decorator function.
+ */
+declare function Session(): Function;
+//#endregion
+//#region src/Types/HooksTypes.d.ts
+declare namespace HooksTypes {
+  interface HookType<T> {
+    new (): T;
+  }
+  type HookData<T> = { [P in keyof T]: T[P] };
+  interface HookCallback<T> {
+    (data: T): void | Promise<void>;
+  }
+  interface HookHandler<T> {
+    id: number;
+    callback: HookCallback<T>;
+  }
+  interface HookID {
+    readonly __id: number;
+    readonly __type: HookType<any>;
+  }
+}
+//#endregion
+//#region src/Decorators/Hooks/Listen.d.ts
+/**
+ * This decorator stores metadata about hook listeners. It can be later used along with function
+ * applyEventListeners() to automatically register all listeners.
+ *
+ * @param hookType hook to listen for
+ * @return decorator function
+ */
+declare function Listen(hookType: HooksTypes.HookType<unknown>): Function;
+//#endregion
+//#region src/Services/Hooks/HooksService.d.ts
+/**
+ * This class is responsible for managing events.
+ */
+declare class HooksService {
+  private fLastId;
+  private fHandlers;
+  /**
+   * Registers listener for event of particular type. Everytime event is called, the listener
+   * will be executed.
+   *
+   * @param type type of event, simple class
+   * @param callback callback fired when event is triggered
+   * @returns unique ID for event listener, can be used to disable this listener
+   */
+  on<T>(type: HooksTypes.HookType<T>, callback: HooksTypes.HookCallback<T>): HooksTypes.HookID;
+  /**
+   * Waits for single event execution and removes the listener immediately after.
+   *
+   * @example
+   * this.gCart.addItem(product);
+   * await this.gEvents.waitFor(CartUpdatedEvent);
+   * console.log('here cart updated event is already called');
+   *
+   * @param type type of event to wait for
+   * @param timeout timeout param in ms - if event is not thrown until this time, it'll reject. passing null disables the timeout
+   * @returns promise with event data that resolves when event is finally called
+   */
+  waitFor<T>(type: HooksTypes.HookType<T>, timeout?: number | null): Promise<T>;
+  /**
+   * Removes listener from particular event.
+   * @param eventId eventId returned from .on() method.
+   * @throws Error if event was not registered
+   */
+  off<T>(eventId: HooksTypes.HookID): void;
+  /**
+   * Triggers event, calling all listener callbacks. Will return Promise of number,
+   * that is resolved when all asynchronous listeners are called.
+   * @param type type of trigger, simple class
+   * @param data data which will be passed to listeners, based on event class
+   * @return number of listeners that were notified
+   */
+  trigger<T>(type: HooksTypes.HookType<T>, data?: HooksTypes.HookData<T>): Promise<number>;
+  /**
+   * Converts plain object to it's class equivalent.
+   * It's NOT class-transformer, it performs basic key assigment.
+   *
+   * @param ClassConstructor event constructor
+   * @param data event data to be mapped to constructor
+   * @return class type of event
+   */
+  private objectToClass;
+}
+//#endregion
+//#region src/Services/Middleware/GlobalMiddlewareRegistry.d.ts
+interface GlobalMiddlewareParams<T> extends Omit<MetadataTypes.Middleware<T>, 'middleware'> {}
+/**
+ * Manages global middleware registration and retrieval
+ *
+ * This class provides functionality to register and retrieve global middleware
+ * configurations. It allows for adding middleware with specific options and
+ * retrieving them in a standardized format.
+ */
+declare class GlobalMiddlewareRegistry {
+  private fMiddlewares;
+  /**
+   * Retrieves all registered global middleware configurations
+   *
+   * @returns {MetadataTypes.Middleware[]} An array of middleware configurations
+   */
+  get middlewares(): MetadataTypes.Middleware[];
+  /**
+   * Registers a global middleware configuration
+   *
+   * @param {typeof BaseMiddleware<T, U>} middleware - The middleware class to register
+   * @param {GlobalMiddlewareParams<T>} opts - The middleware options
+   * @returns {void}
+   */
+  registerGlobalMiddleware<T = unknown, U = unknown>(middleware: typeof BaseMiddleware<T, U>, opts?: GlobalMiddlewareParams<T>): void;
+}
+//#endregion
+//#region src/Services/HttpServer/HttpServer.d.ts
+/**
+ * HTTP server implementation for handling incoming web requests
+ *
+ * This class is responsible for:
+ * - Initializing and managing the HTTP server
+ * - Routing incoming requests to appropriate handlers
+ * - Processing HTTP responses
+ */
+declare class HttpServer {
+  /**
+   * DI container for resolving dependencies
+   */
+  private gContainer;
+  /**
+   * Router service for resolving routes
+   */
+  private gRouter;
+  /**
+   * Handler for processing HTTP requests
+   */
+  private gRequestHandler;
+  /**
+   * Static server for serving static files
+   */
+  private gStaticRequestHandler;
+  /**
+   * Underlying server instance
+   * @private
+   */
+  private fServer;
+  /**
+   * Initializes the HTTP server and starts listening for requests
+   *
+   * @returns {Promise<void>} A promise that resolves when the server is ready
+   */
+  initialize(config: ConfigTypes.Config): Promise<void>;
+  /**
+   * Listens for incoming requests on the HTTP server
+   *
+   * @returns {Promise<void>} A promise that resolves when the server is ready to listen
+   */
+  listen(): Promise<void>;
+  /**
+   * Processes an incoming HTTP request
+   *
+   * This method:
+   * 1. Resolves the route for the request
+   * 2. Returns a 404 response if no route is found
+   * 3. Delegates to the request handler for matched routes
+   *
+   * @param {Request} request - The incoming HTTP request
+   * @returns {Promise<Response>} The HTTP response
+   * @private
+   */
+  handleRequest(request: Request): Promise<Response>;
+}
+//#endregion
+//#region src/Services/Metadata/MetadataResolver.d.ts
+/**
+ * Class responsible for resolving metadata for route handlers.
+ */
+declare class MetadataResolver {
+  /**
+   * Resolves the URL for a given instance and path.
+   *
+   * @param {MetadataTypes.ResolveUrlParams} params - The parameters for resolving the URL.
+   * @return {string} The resolved URL.
+   */
+  resolveUrl(params: MetadataTypes.ResolveUrlParams): string;
+  resolveMethod(ctx: MetadataTypes.Metadata, propertyName: string): MetadataTypes.Method;
+  /**
+   * Resolves arguments for a given event.
+   *
+   * @param {MetadataTypes.Arg[]} args - The arguments to resolve.
+   * @param {RouterTypes.RouterEvent} event - The event to resolve arguments for.
+   * @return {unknown[]} The resolved arguments.
+   * @public
+   */
+  resolveArgs(args: MetadataTypes.Arg[], event: RouterTypes.RouterEvent): Promise<MetadataTypes.Arg[]>;
+  /**
+   * Resolves an argument for a given event.
+   *
+   * @param {MetadataTypes.Arg} arg - The argument to resolve.
+   *
+   * @return {unknown} The resolved argument.
+   * @private
+   */
+  private resolveArg;
+  /**
+   * Resolves middleware functions for a given context and property name.
+   *
+   * @param {MetadataTypes.Ctx} ctx - The metadata context object
+   * @param {string} propertyName - The name of the property to resolve middlewares for
+   * @returns {MetadataTypes.Middleware[]} Array of middleware functions that apply globally or to the specific property
+   * @public
+   */
+  resolveMiddlewares(ctx: MetadataTypes.Metadata, propertyName: string): MetadataTypes.Middleware[];
+}
+//#endregion
+//#region src/Services/ErrorHandler/ErrorHandlerProvider.d.ts
+/**
+ * Abstract class representing an error handler provider
+ * Provides a common interface for different error handler implementations
+ *
+ * @abstract
+ * @class ErrorHandlerProvider
+ */
+declare abstract class ErrorHandlerProvider {
+  /**
+   * Handles an error that occurred during request processing
+   *
+   * @param error - The Error object containing error details
+   * @returns Promise<Response> | Response - The response to be sent to the client
+   */
+  abstract handleError(error: Error): Promise<Response> | Response;
+}
+//#endregion
+//#region src/Services/Router/Router.d.ts
+/**
+ * Router service responsible for managing application routes
+ *
+ * This class provides functionality to initialize the router,
+ * register routes, and resolve incoming requests to their
+ * appropriate handlers.
+ */
+declare class Router {
+  /**
+   * Service for triggering application hooks
+   */
+  private gHooksService;
+  /**
+   * Internal router context that stores all registered routes
+   * @private
+   */
+  private fRouterContext;
+  /**
+   * Registers a new route in the router
+   *
+   * @param {RouterTypes.Route} route - The route configuration to add
+   * @throws {Error} If router is not initialized
+   */
+  addRoute(route: RouterTypes.Route): void;
+  /**
+   * Initializes the router and triggers related hooks
+   *
+   * This method creates a new router context and triggers
+   * the before and after initialization hooks.
+   */
+  initialize(): void;
+  /**
+   * Resolves a route based on the HTTP method and path
+   *
+   * @param {RouterTypes.RouteFind} route - The route to resolve
+   * @returns {RouterTypes.RouteMatched<RouterTypes.RouterHandler> | undefined} The matched route or undefined if no match found
+   */
+  resolve(route: RouterTypes.RouteFind): RouterTypes.RouteMatched<RouterTypes.RouterHandler> | undefined;
+}
+//#endregion
+//#region src/Errors/HttpError.d.ts
+/**
+ * Represents an HTTP error.
+ * @extends {Error}
+ */
+declare class HttpError extends Error {
+  /**
+   * The HTTP status code associated with the error.
+   * @type {number}
+   */
+  status: number;
+  /**
+   * Creates an instance of HttpError.
+   * @param {number} status - The HTTP status code.
+   * @param {string} [message] - The error message.
+   */
+  constructor(status: number, message?: string);
+}
+//#endregion
+//#region src/Errors/Http/BadRequestError.d.ts
+/**
+ * Represents a Bad Request error (HTTP 400).
+ * @extends {HttpError}
+ */
+declare class BadRequestError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of BadRequestError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string, errors?: any);
+}
+//#endregion
+//#region src/Errors/Http/ForbiddenError.d.ts
+/**
+ * Represents a Forbidden error (HTTP 403).
+ * @extends {HttpError}
+ */
+declare class ForbiddenError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of ForbiddenError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/Errors/Http/InternalServerError.d.ts
+/**
+ * Represents an Internal Server error (HTTP 500).
+ * @extends {HttpError}
+ */
+declare class InternalServerError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of InternalServerError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/Errors/Http/MethodNotAllowedError.d.ts
+/**
+ * Represents a Method Not Allowed error (HTTP 405).
+ * @extends {HttpError}
+ */
+declare class MethodNotAllowedError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of MethodNotAllowedError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/Errors/Http/NotAcceptableError.d.ts
+/**
+ * Represents a Not Acceptable error (HTTP 406).
+ * @extends {HttpError}
+ */
+declare class NotAcceptableError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of NotAcceptableError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/Errors/Http/NotFoundError.d.ts
+/**
+ * Represents a Not Found error (HTTP 404).
+ * @extends {HttpError}
+ */
+declare class NotFoundError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of NotFoundError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/Errors/Http/UnauthorizedError.d.ts
+/**
+ * Represents an Unauthorized error (HTTP 401).
+ * @extends {HttpError}
+ */
+declare class UnauthorizedError extends HttpError {
+  /**
+   * The name of the error.
+   * @type {string}
+   */
+  name: string;
+  /**
+   * Creates an instance of UnauthorizedError.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message?: string);
+}
+//#endregion
+//#region src/Utils/Utils.d.ts
+/**
+ * Creates a new metadata context.
+ * @returns {MetadataTypes.Ctx} The new metadata context.
+ */
+declare function createMetadataCtx(): MetadataTypes.Ctx;
+/**
+ * Creates a new metadata method.
+ * @returns {MetadataTypes.Method} The new metadata method.
+ */
+declare function createMetadataMethod(): MetadataTypes.Method;
+/**
+ * Initializes the metadata for a given target and property name.
+ * @param {any} target - The target to initialize metadata for.
+ * @param {string} propertyName - The name of the property to initialize metadata for.
+ */
+declare function initializeMetadataMethod(target: any, propertyName: string): MetadataTypes.Method;
+/**
+ * Initializes the metadata for a given target.
+ * @param {any} target - The target to initialize metadata for.
+ */
+declare function initializeMetadata(target: any): MetadataTypes.Ctx;
+//#endregion
+export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, ConfigTypes, Connect, Controller, Delete, ErrorHandlerProvider, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers, HooksService, HooksTypes, HttpError, HttpServer, InternalServerError, Listen, MaybePromise, MetadataResolver, MetadataTypes, MethodNotAllowedError, Middleware$1 as Middleware, MiddlewareOptions, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request$1 as Request, Response$1 as Response, Router, RouterTypes, Session, SetHeader, Status, Trace, UnauthorizedError, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };