@avleon/core 0.0.46 → 0.0.48

package/dist/index-BxIMWhgy.d.ts

@@ -0,0 +1,1284 @@
+import Container$1, { Constructable, Service } from "typedi";
+import "reflect-metadata";
+import fs, { PathLike } from "node:fs";
+import { ClassConstructor } from "class-transformer";
+import { FastifyInstance, FastifyReply, FastifyRequest, FastifyServerOptions, InjectOptions, LightMyRequestResponse } from "fastify";
+import { DataSource, DataSourceOptions, EntityTarget, ObjectLiteral, Repository } from "typeorm";
+import { MultipartFile, SavedMultipartFile } from "@fastify/multipart";
+import { Knex } from "knex";
+import Bull, { Job, JobOptions, Queue as Queue$1 } from "bull";
+import pino from "pino";
+import { Socket } from "socket.io";
+import { Redis } from "ioredis";
+
+//#region src/openapi.d.ts
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+interface InfoObject {
+  title: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: ContactObject;
+  license?: LicenseObject;
+  version: string;
+}
+interface ContactObject {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+interface LicenseObject {
+  name: string;
+  url?: string;
+}
+interface ServerObject {
+  url: string;
+  description?: string;
+  variables?: {
+    [variable: string]: ServerVariableObject;
+  };
+}
+interface ServerVariableObject {
+  enum?: string[];
+  default: string;
+  description?: string;
+}
+type OpenApiUiOptions = {
+  logo?: any;
+  theme?: any;
+  provider?: "default" | "scalar";
+  ui?: "default" | "scalar";
+  openapi?: string;
+  uiConfig?: any;
+  configuration?: any;
+  routePrefix?: string;
+  info?: InfoObject;
+  servers?: ServerObject[];
+  paths?: PathsObject<any>;
+  components?: ComponentsObject;
+  security?: SecurityRequirementObject[];
+  tags?: TagObject[];
+  externalDocs?: any;
+  "x-express-openapi-additional-middleware"?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+  "x-express-openapi-validation-strict"?: boolean;
+};
+interface PathsObject<T extends {} = {}, P extends {} = {}> {
+  [pattern: string]: (PathItemObject<T> & P) | undefined;
+}
+declare enum HttpMethods {
+  GET = "get",
+  PUT = "put",
+  POST = "post",
+  DELETE = "delete",
+  OPTIONS = "options",
+  HEAD = "head",
+  PATCH = "patch",
+  TRACE = "trace",
+}
+type PathItemObject<T extends {} = {}> = {
+  $ref?: string;
+  summary?: string;
+  description?: string;
+  servers?: ServerObject[];
+  parameters?: (ReferenceObject | ParameterObject)[];
+} & { [method in HttpMethods]?: OperationObject<T> };
+type OperationObject<T extends {} = {}> = {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+  operationId?: string;
+  parameters?: (ReferenceObject | ParameterObject)[];
+  requestBody?: ReferenceObject | RequestBodyObject;
+  responses: ResponsesObject;
+  callbacks?: {
+    [callback: string]: ReferenceObject | CallbackObject;
+  };
+  deprecated?: boolean;
+  security?: SecurityRequirementObject[];
+  servers?: ServerObject[];
+} & T;
+interface ExternalDocumentationObject {
+  description?: string;
+  url: string;
+}
+interface ParameterObject extends ParameterBaseObject {
+  name: string;
+  in: string;
+}
+interface HeaderObject extends ParameterBaseObject {}
+interface ParameterBaseObject {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: ReferenceObject | SchemaObject;
+  example?: any;
+  examples?: {
+    [media: string]: ReferenceObject | ExampleObject;
+  };
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+}
+type NonArraySchemaObjectType = "boolean" | "object" | "number" | "string" | "integer";
+type ArraySchemaObjectType = "array";
+type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+interface ArraySchemaObject extends BaseSchemaObject {
+  type: ArraySchemaObjectType;
+  items: ReferenceObject | SchemaObject;
+}
+interface NonArraySchemaObject extends BaseSchemaObject {
+  type?: NonArraySchemaObjectType;
+}
+interface BaseSchemaObject {
+  title?: string;
+  description?: string;
+  format?: string;
+  default?: any;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: boolean;
+  minimum?: number;
+  exclusiveMinimum?: boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  additionalProperties?: boolean | ReferenceObject | SchemaObject;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  enum?: any[];
+  properties?: {
+    [name: string]: ReferenceObject | SchemaObject;
+  };
+  allOf?: (ReferenceObject | SchemaObject)[];
+  oneOf?: (ReferenceObject | SchemaObject)[];
+  anyOf?: (ReferenceObject | SchemaObject)[];
+  not?: ReferenceObject | SchemaObject;
+  nullable?: boolean;
+  discriminator?: DiscriminatorObject;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  xml?: XMLObject;
+  externalDocs?: ExternalDocumentationObject;
+  example?: any;
+  deprecated?: boolean;
+}
+interface DiscriminatorObject {
+  propertyName: string;
+  mapping?: {
+    [value: string]: string;
+  };
+}
+interface XMLObject {
+  name?: string;
+  namespace?: string;
+  prefix?: string;
+  attribute?: boolean;
+  wrapped?: boolean;
+}
+interface ReferenceObject {
+  $ref: string;
+}
+interface ExampleObject {
+  summary?: string;
+  description?: string;
+  value?: any;
+  externalValue?: string;
+}
+interface MediaTypeObject {
+  schema?: ReferenceObject | SchemaObject;
+  example?: any;
+  examples?: {
+    [media: string]: ReferenceObject | ExampleObject;
+  };
+  encoding?: {
+    [media: string]: EncodingObject;
+  };
+}
+interface EncodingObject {
+  contentType?: string;
+  headers?: {
+    [header: string]: ReferenceObject | HeaderObject;
+  };
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+}
+interface RequestBodyObject {
+  description?: string;
+  content: {
+    [media: string]: MediaTypeObject;
+  };
+  required?: boolean;
+}
+interface ResponsesObject {
+  [code: string]: ReferenceObject | ResponseObject;
+}
+interface ResponseObject {
+  description: string;
+  headers?: {
+    [header: string]: ReferenceObject | HeaderObject;
+  };
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+  links?: {
+    [link: string]: ReferenceObject | LinkObject;
+  };
+}
+interface LinkObject {
+  operationRef?: string;
+  operationId?: string;
+  parameters?: {
+    [parameter: string]: any;
+  };
+  requestBody?: any;
+  description?: string;
+  server?: ServerObject;
+}
+interface CallbackObject {
+  [url: string]: PathItemObject;
+}
+interface SecurityRequirementObject {
+  [name: string]: string[];
+}
+interface ComponentsObject {
+  schemas?: {
+    [key: string]: ReferenceObject | SchemaObject;
+  };
+  responses?: {
+    [key: string]: ReferenceObject | ResponseObject;
+  };
+  parameters?: {
+    [key: string]: ReferenceObject | ParameterObject;
+  };
+  examples?: {
+    [key: string]: ReferenceObject | ExampleObject;
+  };
+  requestBodies?: {
+    [key: string]: ReferenceObject | RequestBodyObject;
+  };
+  headers?: {
+    [key: string]: ReferenceObject | HeaderObject;
+  };
+  securitySchemes?: {
+    [key: string]: ReferenceObject | SecuritySchemeObject;
+  };
+  links?: {
+    [key: string]: ReferenceObject | LinkObject;
+  };
+  callbacks?: {
+    [key: string]: ReferenceObject | CallbackObject;
+  };
+}
+type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+interface HttpSecurityScheme {
+  type: "http";
+  description?: string;
+  scheme: string;
+  bearerFormat?: string;
+}
+interface ApiKeySecurityScheme {
+  type: "apiKey";
+  description?: string;
+  name: string;
+  in: string;
+}
+interface OAuth2SecurityScheme {
+  type: "oauth2";
+  description?: string;
+  flows: {
+    implicit?: {
+      authorizationUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+    password?: {
+      tokenUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+    clientCredentials?: {
+      tokenUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+    authorizationCode?: {
+      authorizationUrl: string;
+      tokenUrl: string;
+      refreshUrl?: string;
+      scopes: {
+        [scope: string]: string;
+      };
+    };
+  };
+}
+interface OpenIdSecurityScheme {
+  type: "openIdConnect";
+  description?: string;
+  openIdConnectUrl: string;
+}
+interface TagObject {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+}
+type ParamSchema = {
+  type?: "string" | "number" | "integer" | "boolean" | "array";
+  description?: string;
+  example?: any;
+  required?: boolean;
+  deprecated?: boolean;
+  enum?: any[];
+  format?: string;
+  default?: any;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+};
+type ParamsSchemaMap = Record<string, ParamSchema>;
+type RequestBodyOptions = {
+  description?: string;
+  required?: boolean;
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+  schema?: SchemaObject | ReferenceObject;
+  example?: any;
+  examples?: Record<string, ExampleObject>;
+};
+type ResponseBodyOptions = {
+  description?: string;
+  type?: NonArraySchemaObjectType | ArraySchemaObjectType;
+  properties?: {
+    [name: string]: ReferenceObject | SchemaObject;
+  };
+  items?: ReferenceObject | SchemaObject;
+  required?: string[];
+  schema?: SchemaObject | ReferenceObject;
+  example?: any;
+  examples?: Record<string, ExampleObject>;
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+} & Partial<BaseSchemaObject>;
+type ResponsesOptions = {
+  [statusCode: number]: ResponseBodyOptions | ResponseObject;
+};
+type OpenApiOptions = {
+  exclude?: boolean;
+  deprecated?: boolean;
+  tags?: readonly string[];
+  description?: string;
+  summary?: string;
+  operationId?: string;
+  security?: SecurityRequirementObject[];
+  externalDocs?: ExternalDocumentationObject;
+  components?: ComponentsObject;
+  /** Path parameters e.g. /:id → { id: { type: "string", example: "abc-123" } } */
+  params?: ParamsSchemaMap;
+  /** Query string parameters e.g. ?page=1 → { page: { type: "integer", example: 1 } } */
+  query?: ParamsSchemaMap;
+  /** Request headers */
+  headers?: ParamsSchemaMap;
+  /** Request body */
+  requestBody?: RequestBodyOptions;
+  /** Responses keyed by HTTP status code */
+  response?: ResponsesOptions;
+  /** @deprecated use requestBody instead */
+  responseBody?: any;
+};
+/**
+ * Normalize a flat ParamsSchemaMap into a valid JSON Schema object
+ * that Fastify/AJV can validate against.
+ *
+ * Input:  { id: { type: "string", example: "abc-123" } }
+ * Output: { type: "object", properties: { id: { type: "string", example: "abc-123" } } }
+ */
+declare function normalizeParamsToJsonSchema(params: ParamsSchemaMap, requiredKeys?: string[]): SchemaObject;
+declare function OpenApiSchema(): ClassDecorator;
+declare function OpenApi(options: OpenApiOptions): MethodDecorator & ClassDecorator & PropertyDecorator;
+//#endregion
+//#region src/swagger-schema.d.ts
+declare function OpenApiProperty$1(options?: ParamSchema & {
+  exclude?: boolean;
+  isArray?: boolean;
+  items?: Record<string, any>;
+  oneOf?: any[];
+  allOf?: any[];
+  anyOf?: any[];
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  title?: string;
+}): (target: any, propertyKey: string) => void;
+declare function CreateSwaggerObjectSchema(classType: any): any;
+declare function generateClassSchema(classType: any): any;
+declare function generateSwaggerSchema(controllers: any[]): any;
+declare function OpenApiResponse$1(code: number | undefined, model: any, description?: string): {
+  description: string;
+  content: {
+    "application/json": {
+      schema: {
+        type: string;
+        properties: {
+          code: {
+            type: string;
+            example: number;
+          };
+          status: {
+            type: string;
+            example: string;
+          };
+          data: any;
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/controller.d.ts
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+declare const REQUEST_METADATA_KEY: unique symbol;
+declare function AvleonRequest(): ParameterDecorator;
+/**
+ * Options for configuring a controller.
+ * @remarks
+ * Controller default options
+ * @type {Object} ControllerOptions
+ * @property {string} [name] - The name of the controller.
+ * @property {string} [path] - The base path for the controller's routes.
+ * @property {string} [version] - The version of the controller. If not provided, it will default to the version from `package.json`.
+ * @property {string} [since] - The date or version since the controller was introduced.
+ * @property {any} [meta] - Additional metadata associated with the controller.
+ */
+type ControllerOptions = {
+  /**
+   *@property {string} name
+   *@description Name of the controller. If specified it'll used as  swagger tags
+   *@default Contorller class name
+   * */
+  name?: string;
+  path?: string;
+  version?: string;
+  since?: string;
+  meta?: any;
+};
+declare function createControllerDecorator(type?: "api" | "web"): (pathOrOptions?: string | ControllerOptions, maybeOptions?: ControllerOptions) => ClassDecorator;
+/**
+ *@description Api controller's are used for rest . It will populate
+ * json on return and all it http methods {get} {post} etc must return
+ *Results.*
+ * @param path {string} this will used as route prefix
+ *
+ **/
+declare function ApiController(target: Function): void;
+declare function ApiController(path: string): ClassDecorator;
+/**
+ *@description Api controller's are used for rest . It will populate
+ * json on return and all it http methods {get} {post} etc must return
+ * Results.*
+ * @param {ControllerOptions} options this will used as route prefix
+ *
+ **/
+declare function ApiController(options: ControllerOptions): ClassDecorator;
+declare function ApiController(path: string, options?: ControllerOptions): ClassDecorator;
+//#endregion
+//#region src/route-methods.d.ts
+type RouteMethods = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "ALL";
+type RouteMethodOptions = {
+  method?: RouteMethods;
+  path?: string;
+  openapi?: OpenApiOptions;
+  name?: string;
+};
+/**
+ * Generic Route decorator factory
+ */
+declare function Route(method: RouteMethods, pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions): MethodDecorator;
+declare const Get: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+declare const Post: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+declare const Put: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+declare const Delete: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+declare const Patch: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+declare const Options: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+declare const All: (pathOrOptions?: string | RouteMethodOptions, maybeOptions?: RouteMethodOptions) => MethodDecorator;
+//#endregion
+//#region src/params.d.ts
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+type ParameterOptions = {
+  required?: boolean;
+  validate?: boolean;
+  type?: any;
+};
+declare const Param: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
+declare const Query: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
+declare const Body: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
+declare const Header: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
+declare const AuthUser: (key?: string | ParameterOptions, options?: ParameterOptions) => ParameterDecorator;
+//#endregion
+//#region src/decorators.d.ts
+declare function AppService(target: any): void;
+declare function AppService(): any;
+declare const Utility: typeof Service;
+declare const Helper: typeof Service;
+//#endregion
+//#region src/utils/common-utils.d.ts
+declare const uuid: `${string}-${string}-${string}-${string}-${string}`;
+type Constructor<T = any> = new (...args: any[]) => T;
+declare function isConstructor(func: any): boolean;
+declare function formatUrl(path: string): string;
+declare function parsedPath(ipath: string): string;
+interface MatchLocation {
+  line: number;
+  column: number;
+}
+declare const getLineNumber: (filePath: string, rpath: string | RegExp) => MatchLocation[] | null;
+declare function normalizePath(base?: string, subPath?: string): string;
+declare function extrctParamFromUrl(url: string): {
+  key: string;
+  required: boolean;
+}[];
+declare function findDuplicates(arr: string[]): string[];
+declare function sleep(ms: number): Promise<unknown>;
+//#endregion
+//#region src/utils/object-utils.d.ts
+declare function pick<T extends object>(obj: T, paths: string[]): Partial<T>;
+declare function exclude<T extends object>(obj: T | T[], paths: string[]): Partial<T> | Partial<T>[];
+declare function autoCast(value: any, typeHint?: any, schema?: any): any;
+/**
+ * Deeply normalizes query strings into nested JS objects.
+ */
+declare function normalizeQueryDeep(query: Record<string, any>): Record<string, any>;
+declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
+declare function jsonToJs(value: string): any;
+declare function jsonToInstance(value: string, instance: Constructor): any;
+//#endregion
+//#region src/utils/validation-utils.d.ts
+declare const isClassValidator: (target: Constructor) => boolean;
+declare function getDataType(expectedType: any): any;
+declare function isValidType(value: any, expectedType: any): boolean;
+declare function isValidJsonString(value: string): object | boolean;
+declare const isClassValidatorClass: (target: Constructor) => boolean;
+declare function validateObjectByInstance(target: Constructor, value?: object, options?: "object" | "array"): Promise<any>;
+type ValidationError = {
+  count: number;
+  errors: any;
+};
+declare function validateRequestBody(target: Constructor, value: object, options?: "object" | "array"): ValidationError;
+//#endregion
+//#region src/utils/di-utils.d.ts
+declare function inject<T>(cls: new (...args: any[]) => T): T;
+//#endregion
+//#region src/validation.d.ts
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+type BaseRule = {
+  required?: boolean;
+  optional?: boolean;
+  message?: string;
+};
+type StringRule = BaseRule & {
+  type: "string";
+};
+type NumberRule = BaseRule & {
+  type: "number";
+  min?: number;
+  max?: number;
+  exact?: number;
+};
+type BooleanRule = BaseRule & {
+  type: "boolean";
+};
+type ValidationRule = StringRule | NumberRule | BooleanRule;
+type ValidationProps = {
+  [key: string]: ValidationRule;
+};
+type ValidateOptons = {
+  location?: "header" | "queryparam" | "param" | "body" | "custom";
+};
+declare class Validator {
+  private rules;
+  private options;
+  constructor(obj: ValidationProps, options?: ValidateOptons);
+  private init;
+  validate(obj: any | Array<any>, options?: ValidateOptons): any[];
+}
+declare function validateOrThrow<T extends {}>(obj: T, rules: ValidationProps, options?: ValidateOptons): any;
+//#endregion
+//#region src/multipart.d.ts
+type MultipartFile$1 = MultipartFile | SavedMultipartFile;
+//#endregion
+//#region src/core/types.d.ts
+interface IRequest extends Omit<FastifyRequest, "files" | "formData" | "file" | "saveRequestFiles"> {
+  params: any;
+  query: any;
+  body: any;
+  headers: any;
+  user?: any;
+  formData?: any;
+  file?: MultipartFile$1;
+  files?: MultipartFile$1[];
+  saveRequestFiles?: (options?: any) => Promise<MultipartFile$1[]>;
+  _argsCache?: Map<string, any[]>;
+}
+interface IResponse extends FastifyReply {}
+interface ParamMetaOptions {
+  index: number;
+  key: string;
+  name: string;
+  required: boolean;
+  validate: boolean;
+  dataType: any;
+  validatorClass: boolean;
+  schema?: any;
+  type: "route:param" | "route:query" | "route:body" | "route:header" | "route:user" | "route:file" | "route:files";
+}
+interface ParamMetaFilesOptions {
+  index: number;
+  type: "route:files";
+  files: MultipartFile$1[];
+  fieldName: string;
+}
+interface MethodParamMeta {
+  request: any[];
+  params: ParamMetaOptions[];
+  query: ParamMetaOptions[];
+  body: ParamMetaOptions[];
+  headers: ParamMetaOptions[];
+  currentUser: ParamMetaOptions[];
+  swagger?: OpenApiUiOptions;
+  file?: any[];
+  files?: ParamMetaFilesOptions[];
+}
+interface IRoute {
+  url: string;
+  method: string;
+  controller: string;
+}
+type FuncRoute = {
+  handler: Function;
+  middlewares: any[];
+  schema: any;
+};
+type StaticFileOptions = {
+  path?: string;
+  prefix?: string;
+};
+//#endregion
+//#region src/exceptions/http-exceptions.d.ts
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+declare abstract class BaseHttpException extends Error {
+  code: number;
+  name: string;
+  payload: any;
+  constructor(message: any);
+  isCustomException(): boolean;
+}
+declare class BadRequestException extends BaseHttpException {
+  name: string;
+  code: number;
+  constructor(message: any);
+}
+declare class ValidationErrorException extends BadRequestException {
+  name: string;
+}
+declare class InternalErrorException extends BaseHttpException {
+  name: string;
+  code: number;
+  constructor(message?: any);
+}
+declare class NotFoundException extends BaseHttpException {
+  name: string;
+  code: number;
+  constructor(message: any);
+}
+declare class UnauthorizedException extends BaseHttpException {
+  name: string;
+  code: number;
+  constructor(message: any);
+}
+declare class ForbiddenException extends BaseHttpException {
+  name: string;
+  code: number;
+  constructor(message: any);
+}
+type HttpExceptionTypes = NotFoundException | BadRequestException | UnauthorizedException | InternalErrorException | ForbiddenException;
+declare const HttpExceptions: {
+  notFound: (message?: any) => NotFoundException;
+  validationError: (message?: any) => ValidationErrorException;
+  badRequest: (message?: any) => BadRequestException;
+  unauthorized: (message?: any) => UnauthorizedException;
+  forbidden: (message?: any) => ForbiddenException;
+  internalError: (message?: any) => InternalErrorException;
+};
+//#endregion
+//#region src/middleware.d.ts
+declare abstract class AvleonMiddleware {
+  abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest | HttpExceptionTypes>;
+}
+type AuthHandler = (req: IRequest, roles?: string[]) => Promise<IRequest | HttpExceptionTypes>;
+declare abstract class AuthorizeMiddleware {
+  abstract authorize(roles: string[]): (req: IRequest, res?: IResponse) => IRequest | Promise<IRequest>;
+}
+type AuthReturnTypes = IRequest | Promise<IRequest>;
+interface AuthorizeClass {
+  authorize(req: IRequest, options?: any): AuthReturnTypes;
+}
+declare function CanAuthorize(target: {
+  new (...args: any[]): AuthorizeClass;
+}): void;
+declare function AppAuthorization(target: {
+  new (...args: any[]): AuthorizeClass;
+}): void;
+declare function Authorized(): ClassDecorator & MethodDecorator;
+declare function Authorized(options?: any): ClassDecorator & MethodDecorator;
+declare function AppMiddleware(target: Constructor<AvleonMiddleware>): void;
+/**
+ * A decorator function that applies one or more middleware to a class or a method.
+ *
+ * When applied to a class, the middleware are registered for the entire controller.
+ * When applied to a method, the middleware are registered for that specific route.
+ *
+ * @param options - A single middleware instance/class or an array of middleware instances/classes to be applied.
+ * @returns A decorator that registers the middleware metadata.
+ */
+declare function UseMiddleware<T extends AvleonMiddleware | (new (...args: any[]) => AvleonMiddleware)>(options: T | T[]): MethodDecorator & ClassDecorator;
+//#endregion
+//#region src/interfaces/avleon-application.d.ts
+type CorsOptions = {
+  origin?: boolean | string | RegExp | (string | RegExp)[] | ((origin: string, cb: (err: Error | null, allow?: boolean) => void) => void);
+  methods?: string | string[];
+  allowedHeaders?: string | string[];
+  exposedHeaders?: string | string[];
+  credentials?: boolean;
+  maxAge?: number;
+  preflight?: boolean;
+  strictPreflight?: boolean;
+  hideOptionsRoute?: boolean;
+  optionsSuccessStatus?: number;
+};
+type GlobalOptions = {
+  cors?: CorsOptions;
+  openApi?: OpenApiUiOptions;
+  controllers?: any;
+  middlewares?: any;
+  authorization?: any;
+  multipart?: any;
+  staticFiles?: any;
+};
+type AvleonApplicationOptions = {
+  server?: FastifyServerOptions;
+  dataSourceOptions?: DataSourceOptions;
+};
+type AutoControllerOptions = {
+  auto: true;
+  path?: string;
+};
+interface IAvleonApplication {
+  useCors: (options: CorsOptions) => this;
+  useDatasource: (dataSource: DataSource) => this;
+  useMultipart: (options?: any) => this;
+  useOpenApi: (options: OpenApiUiOptions) => this;
+  useMiddlewares: (middlewares: Constructor<AvleonMiddleware>[]) => this;
+  useAuthorization: (authorization: Constructor<any>) => this;
+  useSerialization: () => this;
+  useControllers: (controllers: Constructor[] | AutoControllerOptions) => this;
+  useStaticFiles: (options: any) => this;
+  useHttps: (options?: any) => this;
+  useGlobal: (options: GlobalOptions) => this;
+  useSocketIo: (options?: any) => this;
+  useKnex: (options: any) => this;
+  mapFeatures: () => this;
+  mapGet: <T extends (...args: any[]) => any>(path: string, fn: T) => any;
+  mapPost: <T extends (...args: any[]) => any>(path: string, fn: T) => any;
+  mapPut: <T extends (...args: any[]) => any>(path: string, fn: T) => any;
+  mapDelete: <T extends (...args: any[]) => any>(path: string, fn: T) => any;
+  run: (port?: number, fn?: CallableFunction) => Promise<void>;
+}
+type TestResponse = LightMyRequestResponse | Promise<LightMyRequestResponse>;
+interface TestApplication {
+  get: (url: string, options?: InjectOptions) => TestResponse;
+  post: (url: string, options?: InjectOptions) => TestResponse;
+  put: (url: string, options?: InjectOptions) => TestResponse;
+  patch: (url: string, options?: InjectOptions) => TestResponse;
+  delete: (url: string, options?: InjectOptions) => TestResponse;
+  options: (url: string, options?: InjectOptions) => TestResponse;
+  getController: <T>(controller: Constructor<T>, deps?: any[]) => T;
+}
+type TestAppOptions = {
+  controllers: Constructor[] | unknown[];
+  dataSource?: DataSourceOptions;
+};
+//#endregion
+//#region src/core/application.d.ts
+declare class AvleonApplication implements IAvleonApplication {
+  app: FastifyInstance;
+  private router;
+  private static instance;
+  private alreadyRun;
+  private hasSwagger;
+  private globalSwaggerOptions;
+  private dataSourceOptions;
+  private dataSource;
+  private isMapFeatures;
+  private registerControllerAuto;
+  private registerControllerPath;
+  private controllers;
+  private _hasWebsocket;
+  private io;
+  private constructor();
+  static getApp(options?: AvleonApplicationOptions): AvleonApplication;
+  /** @deprecated Use `getApp` instead. This is internal. */
+  static getInternalApp(options?: AvleonApplicationOptions): AvleonApplication;
+  useCors(options: CorsOptions): this;
+  useDatasource(dataSource: any): this;
+  useMultipart(options?: any): this;
+  useOpenApi(options: OpenApiUiOptions): this;
+  private initSwagger;
+  useMiddlewares(middlewares: Constructor<AvleonMiddleware>[]): this;
+  useAuthorization(authorization: Constructor<any>): this;
+  useSerialization(): this;
+  useControllers(controllers: Constructor[] | AutoControllerOptions): this;
+  useStaticFiles(options?: any): this;
+  useHttps(options?: any): this;
+  useGlobal(options: GlobalOptions): this;
+  useSocketIo(options?: any): this;
+  useKnex(options: any): this;
+  mapFeatures(): this;
+  isDevelopment(): boolean;
+  private _mapControllers;
+  private _resolveControllerDir;
+  private autoControllers;
+  private _mapFeatures;
+  initializeDatabase(): Promise<void>;
+  handleSocket(socket: any): void;
+  mapGet<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+    useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/any;
+    useOpenApi: (options: OpenApiOptions) => /*elided*/any;
+  };
+  mapPost<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+    useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/any;
+    useOpenApi: (options: OpenApiOptions) => /*elided*/any;
+  };
+  mapPut<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+    useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/any;
+    useOpenApi: (options: OpenApiOptions) => /*elided*/any;
+  };
+  mapDelete<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+    useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/any;
+    useOpenApi: (options: OpenApiOptions) => /*elided*/any;
+  };
+  run(port?: number, fn?: CallableFunction): Promise<void>;
+}
+//#endregion
+//#region src/core/testing.d.ts
+declare class AvleonTest {
+  private constructor();
+  static getController<T>(controller: Constructor<T>, deps?: any[]): T;
+  static getProvider<T>(service: Constructor<T>, deps?: any[]): T;
+  static createTestApplication(options: TestAppOptions): TestApplication;
+  static from(app: AvleonApplication): TestApplication;
+  static clean(): void;
+}
+declare class Avleon {
+  static createApplication(): AvleonApplication;
+  static createTestApplication(options: TestAppOptions): TestApplication;
+}
+//#endregion
+//#region src/response.d.ts
+interface IHttpResponse<T extends any> {
+  message: string;
+  data: T | null;
+}
+declare class HttpResponse {
+  static Ok<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T>;
+  static Created<T>(obj: any, s?: ClassConstructor<T>): IHttpResponse<T>;
+  static NoContent(): IHttpResponse<null>;
+}
+//#endregion
+//#region src/container.d.ts
+declare const FEATURE_KEY: unique symbol;
+declare const ROUTE_META_KEY: unique symbol;
+declare const CONTROLLER_META_KEY: unique symbol;
+declare const PARAM_META_KEY: unique symbol;
+declare const QUERY_META_KEY: unique symbol;
+declare const REQUEST_BODY_META_KEY: unique symbol;
+declare const REQUEST_BODY_FILE_KEY: unique symbol;
+declare const REQUEST_BODY_FILES_KEY: unique symbol;
+declare const REQUEST_USER_META_KEY: unique symbol;
+declare const REQUEST_HEADER_META_KEY: unique symbol;
+declare const DATASOURCE_META_KEY: unique symbol;
+declare const AUTHORIZATION_META_KEY: unique symbol;
+declare const Container: typeof Container$1;
+declare function registerController(controller: Function): void;
+declare function registerService(service: Function): void;
+declare function getRegisteredServices(): Function[];
+declare function getRegisteredControllers(): Function[];
+declare const API_CONTROLLER_METADATA_KEY: unique symbol;
+declare function isApiController(target: Function): boolean;
+declare function registerDataSource(dataSource: any): void;
+declare function registerKnex(dataSource: Knex.Config): void;
+//#endregion
+//#region src/kenx-provider.d.ts
+declare class DB {
+  private connection;
+  constructor();
+  init(config: Knex.Config): Knex<any, any[]>;
+  get client(): Knex;
+}
+//#endregion
+//#region src/collection.d.ts
+type Predicate<T> = (item: T) => boolean;
+type ValueOperator<T> = {
+  $in?: T[];
+};
+type FieldCondition<T> = T | ValueOperator<T>;
+type WhereCondition<T> = { [K in keyof T]?: FieldCondition<T[K]> };
+type LogicalOperators<T> = {
+  $and: Where<T>[];
+} | {
+  $or: Where<T>[];
+} | {
+  $not: Where<T>;
+};
+type Where<T> = WhereCondition<T> | LogicalOperators<T>;
+interface IFindOneOptions<T = any> {
+  where: Where<T>;
+}
+type PaginationResult<T> = {
+  total: number;
+  data: T[];
+  next?: number | null;
+  prev?: number | null;
+  first?: number | null;
+  last?: number | null;
+  totalPage?: number;
+};
+interface BasicCollection<T> {
+  clear(): void;
+  find(predicate?: Predicate<T>): T[];
+  findAsync(predicate?: Predicate<T>): Promise<T[]>;
+  findOne(predicate: Predicate<T> | IFindOneOptions<T>): T | undefined;
+  findOneAsync(predicate: Predicate<T> | IFindOneOptions<T>): Promise<T | undefined>;
+}
+declare class Collection {
+  private constructor();
+  static from<T>(items: T[]): BasicCollection<T>;
+  static fromRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
+}
+declare function InjectRepository<T extends Repository<T>>(model: EntityTarget<T>): (object: any, propertyName: string | undefined, index?: number) => void;
+//#endregion
+//#region src/event-dispatcher.d.ts
+declare class SocketContextService {
+  private readonly storage;
+  run(socket: Socket, fn: () => void | Promise<void>): void;
+  getSocket(): Socket | undefined;
+}
+type DispatchOptions = {
+  room?: string;
+  broadcast?: boolean;
+  transports?: ("socket" | "kafka" | "rabbitmq")[];
+  retry?: number;
+  retryDelay?: number;
+};
+declare class EventDispatcher {
+  private readonly _context;
+  constructor(_context: SocketContextService);
+  dispatch<T = any>(event: string, data: T, options?: DispatchOptions): Promise<void>;
+  private dispatchToTransports;
+}
+declare function Dispatch(event: string, options?: Omit<DispatchOptions, "transports"> & {
+  transports?: DispatchOptions["transports"];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+//#endregion
+//#region src/event-subscriber.d.ts
+declare function Private(channelResolver?: (socket: any) => string): (target: any, propertyKey: string) => void;
+declare function isPrivate(target: any, propertyKey: string): boolean;
+declare function getPrivateChannelResolver(target: any, propertyKey: string): ((socket: any) => string) | undefined;
+declare function registerSocketSubscriber(target: Function): void;
+declare function getSocketSubscribers(): Function[];
+declare function Subscribe(event: string): MethodDecorator;
+declare class EventSubscriberRegistry {
+  private readonly socketContext;
+  constructor(socketContext: SocketContextService);
+  register(socket: Socket): void;
+}
+//#endregion
+//#region src/queue.d.ts
+interface QueueConfig {
+  name: string;
+  adapter?: any;
+  handler?: (job: Job) => Promise<any>;
+  options?: Bull.QueueOptions;
+}
+declare class AvleonQueue<T = any> {
+  protected name?: string | undefined;
+  protected adapter?: any | undefined;
+  protected queue: Queue$1<T>;
+  protected handlerFn?: (job: Job<T>) => Promise<any>;
+  constructor(name?: string | undefined, adapter?: any | undefined, handler?: (job: Job<T>) => Promise<any>);
+  handler?(job: Job<T>): Promise<any> | any;
+  add(data: T, options?: JobOptions): Promise<Bull.Job<T>>;
+  delay(data: T, delayMs: number, options?: JobOptions): Promise<Bull.Job<T>>;
+  process(handler: (job: Job<T>) => Promise<any>): void;
+  processConcurrent(concurrency: number, handler: (job: Job<T>) => Promise<any>): void;
+  getQueue(): Queue$1<T>;
+  clean(grace: number, status?: 'completed' | 'wait' | 'active' | 'delayed' | 'failed'): Promise<Job[]>;
+  close(): Promise<void>;
+  pause(): Promise<void>;
+  resume(): Promise<void>;
+  getJob(jobId: string): Promise<Job<T> | null>;
+  getJobs(types: Array<'completed' | 'waiting' | 'active' | 'delayed' | 'failed' | 'paused'>, start?: number, end?: number): Promise<Job<T>[]>;
+}
+declare function Queue(config: QueueConfig): <T extends {
+  new (...args: any[]): AvleonQueue;
+}>(target: T) => T;
+//#endregion
+//#region src/file-storage.d.ts
+interface TransformOptions {
+  resize?: {
+    width: number;
+    height: number;
+  };
+  format?: "jpeg" | "png" | "webp" | "avif";
+  quality?: number;
+}
+interface FileStorageInterface {
+  transform(options: TransformOptions): FileStorage;
+  save(file: MultipartFile$1, options?: SaveOptionsSingle): Promise<MultipartFile$1>;
+  saveAll(files: MultipartFile$1[], options?: SaveOptions): Promise<MultipartFile$1[]>;
+  remove(filepath: string): Promise<void>;
+}
+interface SaveOptions {
+  overwrite?: boolean;
+  to?: string;
+}
+interface SaveOptionsSingle extends SaveOptions {
+  saveAs?: string;
+}
+declare class FileStorage implements FileStorageInterface {
+  private transformOptions;
+  private readonly baseDir;
+  private readonly maxFileSize;
+  constructor();
+  /**
+   * Set transformation options for the next save operation
+   */
+  transform(options: TransformOptions): FileStorage;
+  getUploadFile(fliePath: string): Promise<NonSharedBuffer>;
+  download(filepath: PathLike): Promise<{
+    download: boolean;
+    stream: fs.ReadStream;
+    filename: string;
+  }>;
+  downloadAs(filepath: PathLike, filename: string): Promise<{
+    download: boolean;
+    stream: fs.ReadStream;
+    filename: string;
+  }>;
+  /**
+   * Save a single file with optional transformations
+   */
+  save(f: MultipartFile$1, options?: SaveOptionsSingle): Promise<any>;
+  /**
+   * Save multiple files
+   */
+  saveAll(files: MultipartFile$1[], options?: SaveOptions): Promise<any[]>;
+  /**
+   * Remove a file from storage
+   */
+  remove(filepath: string): Promise<void>;
+  /**
+   * Process image with transformations using sharp
+   */
+  private processImage;
+  /**
+   * Helper methods
+   */
+  private isFileExists;
+  private ensureDirectoryExists;
+  private removeFileSync;
+  private isImageFile;
+  private validateFilename;
+}
+//#endregion
+//#region src/environment-variables.d.ts
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+/**
+ * @class Environment
+ * @description A service class to manage access to environment variables.
+ * It loads variables from `.env` file and merges them with `process.env`,
+ * giving precedence to `process.env` values.
+ */
+declare class Environment {
+  /**
+  * Parses the given `.env` file and merges it with `process.env`.
+  * Values from `process.env` take precedence.
+  *
+  * @private
+  * @param filePath - Absolute path to the `.env` file.
+  * @returns A dictionary of merged environment variables.
+  */
+  private parseEnvFile;
+  /**
+  * Retrieves the value of the specified environment variable.
+  *
+  * @template T
+  * @param key - The name of the environment variable.
+  * @returns The value of the variable, or `undefined` if not found.
+  */
+  get<T = any>(key: string): T;
+  /**
+  * Retrieves the value of the specified environment variable.
+  * Throws an error if the variable is not found.
+  *
+  * @template T
+  * @param key - The name of the environment variable.
+  * @throws {EnvironmentVariableNotFound} If the variable does not exist.
+  * @returns The value of the variable.
+  */
+  getOrThrow<T = any>(key: string): T;
+  /**
+  * Retrieves all available environment variables,
+  * with `process.env` values taking precedence over `.env` values.
+  *
+  * @template T
+  * @returns An object containing all environment variables.
+  */
+  getAll<T = any>(): T;
+}
+//#endregion
+//#region src/config.d.ts
+interface IConfig<T = any> {
+  config(env: Environment): T;
+}
+declare function AppConfig<T extends IConfig>(target: Constructable<T>): void;
+declare class AvleonConfig {
+  get<T extends IConfig<R>, R>(configClass: Constructable<T>): R;
+}
+declare function GetConfig<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>): R;
+declare function GetConfig<T = any>(config: string | symbol): T;
+declare function CreateConfig<T>(token: string | symbol, callback: (env: Environment) => T): void;
+//#endregion
+//#region src/logger.d.ts
+declare class LoggerService {
+  private logger;
+  constructor();
+  getLogger(): pino.Logger;
+  info(message: string, obj?: any): void;
+  error(message: string, obj?: any): void;
+  warn(message: string, obj?: any): void;
+  debug(message: string, obj?: any): void;
+  fatal(message: string, obj?: any): void;
+  trace(message: string, obj?: any): void;
+}
+//#endregion
+//#region src/cache.d.ts
+declare class CacheManager {
+  private store;
+  private tagsMap;
+  private redis;
+  constructor(redisInstance?: Redis);
+  private redisTagKey;
+  get<T>(key: string): Promise<T | null>;
+  set<T>(key: string, value: T, tags?: string[], ttl?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+  invalidateTag(tag: string): Promise<void>;
+}
+//#endregion
+//#region src/results.d.ts
+type OkOptions = {
+  streamable: boolean;
+};
+declare class Results {
+  static code: number;
+  message: string;
+  static Ok<T>(data: T): Ok<T>;
+  static NoContent(): void;
+  static OkStream(): void;
+  static NotFound<T>(message: T): NotFound<T>;
+}
+declare class Ok<T> {
+  data: T;
+  constructor(data: T);
+}
+declare class NotFound<T> {
+  message: T;
+  constructor(message: T);
+}
+type RouteResult<T = any> = typeof Results.Ok<T>;
+//#endregion
+//#region src/index.d.ts
+declare const GetSchema: typeof generateSwaggerSchema;
+declare const GetObjectSchema: typeof CreateSwaggerObjectSchema;
+declare const OpenApiOk: (args1: any) => {
+  description: string;
+  content: {
+    "application/json": {
+      schema: {
+        type: string;
+        properties: {
+          code: {
+            type: string;
+            example: number;
+          };
+          status: {
+            type: string;
+            example: string;
+          };
+          data: any;
+        };
+      };
+    };
+  };
+};
+declare const OpenApiResponse: typeof OpenApiResponse$1;
+declare const OpenApiProperty: typeof OpenApiProperty$1;
+//#endregion
+export { API_CONTROLLER_METADATA_KEY, AUTHORIZATION_META_KEY, All, ApiController, ApiKeySecurityScheme, AppAuthorization, AppConfig, AppMiddleware, AppService, ArraySchemaObject, ArraySchemaObjectType, AuthHandler, AuthReturnTypes, AuthUser, AuthorizeMiddleware, Authorized, AutoControllerOptions, Avleon, AvleonApplication, AvleonApplicationOptions, AvleonConfig, Container as AvleonContainer, AvleonMiddleware, AvleonQueue, AvleonRequest, AvleonTest, BadRequestException, BaseHttpException, BaseSchemaObject, BasicCollection, Body, CONTROLLER_META_KEY, CacheManager, CallbackObject, CanAuthorize, Collection, ComponentsObject, Constructor, ContactObject, ControllerOptions, CorsOptions, CreateConfig, CreateSwaggerObjectSchema, DATASOURCE_META_KEY, DB, Delete, DiscriminatorObject, Dispatch, DispatchOptions, EncodingObject, Environment, EventDispatcher, EventSubscriberRegistry, ExampleObject, ExternalDocumentationObject, FEATURE_KEY, FileStorage, FileStorageInterface, ForbiddenException, FuncRoute, Get, GetConfig, GetObjectSchema, GetSchema, GlobalOptions, Header, HeaderObject, Helper, HttpExceptionTypes, HttpExceptions, HttpResponse, HttpSecurityScheme, IAvleonApplication, IConfig, IFindOneOptions, IHttpResponse, IRequest, IResponse, IRoute, InfoObject, InjectRepository, InternalErrorException, LicenseObject, LinkObject, LoggerService, MatchLocation, MediaTypeObject, MethodParamMeta, NonArraySchemaObject, NonArraySchemaObjectType, NotFound, NotFoundException, OAuth2SecurityScheme, Ok, OkOptions, OpenApi, OpenApiOk, OpenApiOptions, OpenApiProperty, OpenApiResponse, OpenApiSchema, OpenApiUiOptions, OpenIdSecurityScheme, OperationObject, Options, PARAM_META_KEY, PaginationResult, Param, ParamMetaFilesOptions, ParamMetaOptions, ParamSchema, ParameterBaseObject, ParameterObject, ParamsSchemaMap, Patch, PathItemObject, PathsObject, Post, Private, Put, QUERY_META_KEY, Query, Queue, QueueConfig, REQUEST_BODY_FILES_KEY, REQUEST_BODY_FILE_KEY, REQUEST_BODY_META_KEY, REQUEST_HEADER_META_KEY, REQUEST_METADATA_KEY, REQUEST_USER_META_KEY, ROUTE_META_KEY, ReferenceObject, RequestBodyObject, RequestBodyOptions, ResponseBodyOptions, ResponseObject, ResponsesObject, ResponsesOptions, Results, Route, RouteMethodOptions, RouteMethods, RouteResult, SaveOptions, SaveOptionsSingle, SchemaObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject, ServerVariableObject, SocketContextService, StaticFileOptions, Subscribe, TagObject, TestAppOptions, TestApplication, TestResponse, UnauthorizedException, UseMiddleware, Utility, ValidateOptons, ValidationErrorException, ValidationProps, ValidationRule, Validator, XMLObject, autoCast, createControllerDecorator, exclude, extrctParamFromUrl, findDuplicates, formatUrl, generateClassSchema, generateSwaggerSchema, getDataType, getLineNumber, getPrivateChannelResolver, getRegisteredControllers, getRegisteredServices, getSocketSubscribers, inject, isApiController, isClassValidator, isClassValidatorClass, isConstructor, isPrivate, isValidJsonString, isValidType, jsonToInstance, jsonToJs, normalizeParamsToJsonSchema, normalizePath, normalizeQueryDeep, parsedPath, pick, registerController, registerDataSource, registerKnex, registerService, registerSocketSubscriber, sleep, transformObjectByInstanceToObject, uuid, validateObjectByInstance, validateOrThrow, validateRequestBody };
+//# sourceMappingURL=index-BxIMWhgy.d.ts.map