@avleon/core 0.0.44 → 0.0.46

package/dist/index.d.ts

@@ -5,28 +5,30 @@
  * @url https://github.com/xtareq
  */
 import * as sw from "./swagger-schema";
-export * from "./icore";
-export * from "./testing";
-export { inject, validateRequestBody, pick, exclude } from "./helpers";
+import "reflect-metadata";
 export * from "./decorators";
-export * from "./middleware";
-export * from "./config";
-export * from "./openapi";
-export * from "./map-types";
+export * from "./interfaces/avleon-application";
+export * from "./core/application";
+export * from "./core/testing";
+export * from "./core/types";
+export * from "./helpers";
 export * from "./response";
 export * from "./exceptions";
-export * from "./validator-extend";
-export * from "./validation";
-export * from "./environment-variables";
+export * from "./openapi";
+export * from "./swagger-schema";
+export * from "./container";
+export * from "./middleware";
+export * from "./kenx-provider";
 export * from "./collection";
+export * from "./event-dispatcher";
+export * from "./event-subscriber";
 export * from "./queue";
-export * from "./utils/hash";
-export * from "./multipart";
 export * from "./file-storage";
+export * from "./config";
 export * from "./logger";
-export * from "./event-dispatcher";
-export * from "./kenx-provider";
-export { Subscribe, Private } from "./event-subscriber";
+export * from "./cache";
+export * from "./results";
+export * from "./environment-variables";
 export declare const GetSchema: typeof sw.generateSwaggerSchema;
 export declare const GetObjectSchema: typeof sw.CreateSwaggerObjectSchema;
 export declare const OpenApiOk: (args1: any) => {

package/dist/index.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvleonContainer = exports.OpenApiProperty = exports.OpenApiResponse = exports.OpenApiOk = exports.GetObjectSchema = exports.GetSchema = exports.Private = exports.Subscribe = exports.exclude = exports.pick = exports.validateRequestBody = exports.inject = void 0;
+exports.AvleonContainer = exports.OpenApiProperty = exports.OpenApiResponse = exports.OpenApiOk = exports.GetObjectSchema = exports.GetSchema = void 0;
 /**
  * @copyright 2024
  * @author Tareq Hossain
@@ -47,34 +47,30 @@ exports.AvleonContainer = exports.OpenApiProperty = exports.OpenApiResponse = ex
  * @url https://github.com/xtareq
  */
 const sw = __importStar(require("./swagger-schema"));
-__exportStar(require("./icore"), exports);
-__exportStar(require("./testing"), exports);
-var helpers_1 = require("./helpers");
-Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return helpers_1.inject; } });
-Object.defineProperty(exports, "validateRequestBody", { enumerable: true, get: function () { return helpers_1.validateRequestBody; } });
-Object.defineProperty(exports, "pick", { enumerable: true, get: function () { return helpers_1.pick; } });
-Object.defineProperty(exports, "exclude", { enumerable: true, get: function () { return helpers_1.exclude; } });
+require("reflect-metadata");
 __exportStar(require("./decorators"), exports);
-__exportStar(require("./middleware"), exports);
-__exportStar(require("./config"), exports);
-__exportStar(require("./openapi"), exports);
-__exportStar(require("./map-types"), exports);
+__exportStar(require("./interfaces/avleon-application"), exports);
+__exportStar(require("./core/application"), exports);
+__exportStar(require("./core/testing"), exports);
+__exportStar(require("./core/types"), exports);
+__exportStar(require("./helpers"), exports);
 __exportStar(require("./response"), exports);
 __exportStar(require("./exceptions"), exports);
-__exportStar(require("./validator-extend"), exports);
-__exportStar(require("./validation"), exports);
-__exportStar(require("./environment-variables"), exports);
+__exportStar(require("./openapi"), exports);
+__exportStar(require("./swagger-schema"), exports);
+__exportStar(require("./container"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./kenx-provider"), exports);
 __exportStar(require("./collection"), exports);
+__exportStar(require("./event-dispatcher"), exports);
+__exportStar(require("./event-subscriber"), exports);
 __exportStar(require("./queue"), exports);
-__exportStar(require("./utils/hash"), exports);
-__exportStar(require("./multipart"), exports);
 __exportStar(require("./file-storage"), exports);
+__exportStar(require("./config"), exports);
 __exportStar(require("./logger"), exports);
-__exportStar(require("./event-dispatcher"), exports);
-__exportStar(require("./kenx-provider"), exports);
-var event_subscriber_1 = require("./event-subscriber");
-Object.defineProperty(exports, "Subscribe", { enumerable: true, get: function () { return event_subscriber_1.Subscribe; } });
-Object.defineProperty(exports, "Private", { enumerable: true, get: function () { return event_subscriber_1.Private; } });
+__exportStar(require("./cache"), exports);
+__exportStar(require("./results"), exports);
+__exportStar(require("./environment-variables"), exports);
 exports.GetSchema = sw.generateSwaggerSchema;
 exports.GetObjectSchema = sw.CreateSwaggerObjectSchema;
 const OpenApiOk = (args1) => {

package/dist/interfaces/avleon-application.d.ts

@@ -1,27 +1,75 @@
-interface AvleonApplication {
-    useCors: () => void;
-    /**
-     * function for register database
-     * @param options datasource options. options can be plain object or avleon config class
-     * */
-    useDatasource: () => void;
-    useMultipart: () => void;
-    useOpenApi: () => void;
-    useMiddlewares: () => void;
-    useAuthorization: () => void;
-    useSerialization: () => void;
-    useControllers: () => void;
-    useStaticFiles: () => void;
-    /**
-     * @experimental
-     * use https as defalut http protocol
-     * */
-    useHttps: () => void;
-    mapGet: () => void;
-    mapPost: () => void;
-    mapPut: () => void;
-    mapPatch: () => void;
-    mapOptions: () => void;
-    mapGroup: () => void;
-    run: () => void;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { Constructor } from "../helpers";
+import { AvleonMiddleware } from "../middleware";
+import { DataSource, DataSourceOptions } from "typeorm";
+import { OpenApiUiOptions } from "../openapi";
+import { FastifyServerOptions, InjectOptions, LightMyRequestResponse } from "fastify";
+export 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;
+};
+export type GlobalOptions = {
+    cors?: CorsOptions;
+    openApi?: OpenApiUiOptions;
+    controllers?: any;
+    middlewares?: any;
+    authorization?: any;
+    multipart?: any;
+    staticFiles?: any;
+};
+export type AvleonApplicationOptions = {
+    server?: FastifyServerOptions;
+    dataSourceOptions?: DataSourceOptions;
+};
+export type AutoControllerOptions = {
+    auto: true;
+    path?: string;
+};
+export 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>;
 }
+export type TestResponse = LightMyRequestResponse | Promise<LightMyRequestResponse>;
+export 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;
+}
+export type TestAppOptions = {
+    controllers: Constructor[] | unknown[];
+    dataSource?: DataSourceOptions;
+};

package/dist/interfaces/avleon-application.js

@@ -1 +1,2 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/middleware.d.ts

@@ -1,12 +1,10 @@
-import { IRequest, IResponse } from "./icore";
+import { IRequest, IResponse } from "./core/types";
 import { HttpExceptionTypes as HttpException } from "./exceptions";
+import { Constructor } from "./helpers";
 export declare abstract class AvleonMiddleware {
     abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest | HttpException>;
 }
 export type AuthHandler = (req: IRequest, roles?: string[]) => Promise<IRequest | HttpException>;
-export type Constructor<T> = {
-    new (...args: any[]): T;
-};
 export declare abstract class AuthorizeMiddleware {
     abstract authorize(roles: string[]): (req: IRequest, res?: IResponse) => IRequest | Promise<IRequest>;
 }
@@ -23,5 +21,14 @@ export declare function AppAuthorization(target: {
 export declare function Authorized(): ClassDecorator & MethodDecorator;
 export declare function Authorized(options?: any): ClassDecorator & MethodDecorator;
 export 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.
+ */
 export declare function UseMiddleware<T extends AvleonMiddleware | (new (...args: any[]) => AvleonMiddleware)>(options: T | T[]): MethodDecorator & ClassDecorator;
 export {};

package/dist/middleware.js

@@ -48,6 +48,15 @@ function AppMiddleware(target) {
     }
     (0, typedi_1.Service)()(target);
 }
+/**
+ * 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.
+ */
 function UseMiddleware(options) {
     return function (target, propertyKey, descriptor) {
         const normalizeMiddleware = (middleware) => typeof middleware === "function" ? new middleware() : middleware;

package/dist/multipart.d.ts

@@ -5,7 +5,7 @@
  * @url https://github.com/xtareq
  */
 import { MultipartFile as FsM, SavedMultipartFile } from "@fastify/multipart";
-import { IRequest } from "./icore";
+import { IRequest } from "./core/types";
 export declare function UploadFile(fieldName: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
 export declare function UploadFiles(fieldName?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
 type Foptions = {
@@ -13,5 +13,5 @@ type Foptions = {
     dest?: true;
 };
 export type MultipartFile = FsM | SavedMultipartFile;
-export declare function UploadFileFromRequest(req: IRequest, options?: Foptions): Promise<FsM | undefined>;
+export declare function UploadFileFromRequest(req: IRequest, options?: Foptions): Promise<any>;
 export {};

package/dist/openapi.d.ts

@@ -36,8 +36,10 @@ export interface ServerVariableObject {
 export type OpenApiUiOptions = {
     logo?: any;
     theme?: any;
+    provider?: "default" | "scalar";
     ui?: "default" | "scalar";
     openapi?: string;
+    uiConfig?: any;
     configuration?: any;
     routePrefix?: string;
     info?: InfoObject;
@@ -328,16 +330,81 @@ export interface TagObject {
     description?: string;
     externalDocs?: ExternalDocumentationObject;
 }
+export 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;
+};
+export type ParamsSchemaMap = Record<string, ParamSchema>;
+export type RequestBodyOptions = {
+    description?: string;
+    required?: boolean;
+    content?: {
+        [media: string]: MediaTypeObject;
+    };
+    schema?: SchemaObject | ReferenceObject;
+    example?: any;
+    examples?: Record<string, ExampleObject>;
+};
+export 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>;
+export type ResponsesOptions = {
+    [statusCode: number]: ResponseBodyOptions | ResponseObject;
+};
 export type OpenApiOptions = {
     exclude?: boolean;
     deprecated?: boolean;
     tags?: readonly string[];
     description?: string;
     summary?: string;
+    operationId?: string;
+    security?: SecurityRequirementObject[];
+    externalDocs?: ExternalDocumentationObject;
     components?: ComponentsObject;
-    response?: any;
+    /** 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;
-    requestBody?: any;
-} & 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" } } }
+ */
+export declare function normalizeParamsToJsonSchema(params: ParamsSchemaMap, requiredKeys?: string[]): SchemaObject;
+export declare function OpenApiSchema(): ClassDecorator;
 export declare function OpenApi(options: OpenApiOptions): MethodDecorator & ClassDecorator & PropertyDecorator;
 export {};

package/dist/openapi.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeParamsToJsonSchema = normalizeParamsToJsonSchema;
+exports.OpenApiSchema = OpenApiSchema;
 exports.OpenApi = OpenApi;
 var HttpMethods;
 (function (HttpMethods) {
@@ -12,12 +14,42 @@ var HttpMethods;
     HttpMethods["PATCH"] = "patch";
     HttpMethods["TRACE"] = "trace";
 })(HttpMethods || (HttpMethods = {}));
+/**
+ * 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" } } }
+ */
+function normalizeParamsToJsonSchema(params, requiredKeys = []) {
+    const properties = {};
+    for (const [key, val] of Object.entries(params)) {
+        properties[key] = {
+            type: "string", // sensible default
+            ...val,
+        };
+    }
+    const schema = {
+        type: "object",
+        properties,
+    };
+    if (requiredKeys.length > 0) {
+        schema.required = requiredKeys;
+    }
+    return schema;
+}
+function OpenApiSchema() {
+    return function (target) {
+        Reflect.defineMetadata("openapi:schema", true, target);
+    };
+}
 function OpenApi(options) {
     return function (target, propertyKey, descriptor) {
         if (typeof target === "function" && !propertyKey) {
             Reflect.defineMetadata("controller:openapi", options, target);
         }
         else if (descriptor) {
+            // ✅ Store options as-is — router's buildRouteSchema handles normalization
             Reflect.defineMetadata("route:openapi", options, target, propertyKey);
         }
         else if (propertyKey) {

package/dist/params.js

@@ -14,7 +14,6 @@ function createParamDecorator(type) {
     return function (key, options = {}) {
         return function (target, propertyKey, parameterIndex) {
             var _a, _b, _c, _d;
-            // Determine correct meta key
             let metaKey;
             switch (type) {
                 case "route:param":
@@ -35,15 +34,12 @@ function createParamDecorator(type) {
                 default:
                     throw new Error(`Unknown param decorator type: ${String(type)}`);
             }
-            // Retrieve and preserve existing metadata
             const existingParams = Reflect.getMetadata(metaKey, target, propertyKey) || [];
             // Get parameter names (fallback safe)
             const functionSource = target[propertyKey].toString();
             const paramNames = ((_b = (_a = functionSource.match(/\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.split(",").map((n) => n.trim())) || [];
-            // Determine the param type
             const parameterTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
             const paramDataType = parameterTypes[parameterIndex];
-            // Append new parameter
             existingParams.push({
                 index: parameterIndex,
                 key: typeof key === "string" ? key : "all",
@@ -53,11 +49,10 @@ function createParamDecorator(type) {
                 dataType: (0, helpers_1.getDataType)(paramDataType),
                 validatorClass: (0, helpers_1.isClassValidatorClass)(paramDataType),
                 schema: (0, helpers_1.isClassValidatorClass)(paramDataType)
-                    ? (0, swagger_schema_1.generateSwaggerSchema)(paramDataType)
+                    ? (0, swagger_schema_1.generateClassSchema)(paramDataType)
                     : null,
                 type,
             });
-            // Save back using the correct meta key
             Reflect.defineMetadata(metaKey, existingParams, target, propertyKey);
         };
     };

package/dist/params.test.js

@@ -40,26 +40,26 @@ describe("Parameter Decorators", () => {
     it("should define metadata for Query decorator", () => {
         const meta = Reflect.getMetadata(container_1.QUERY_META_KEY, TestController.prototype, "testMethod");
         expect(meta).toBeDefined();
-        expect(meta[1].key).toBe("search");
-        expect(meta[1].type).toBe("route:query");
+        expect(meta[0].key).toBe("search");
+        expect(meta[0].type).toBe("route:query");
     });
     it("should define metadata for Body decorator", () => {
         const meta = Reflect.getMetadata(container_1.REQUEST_BODY_META_KEY, TestController.prototype, "testMethod");
         expect(meta).toBeDefined();
-        expect(meta[2].key).toBe("all");
-        expect(meta[2].type).toBe("route:body");
+        expect(meta[0].key).toBe("all");
+        expect(meta[0].type).toBe("route:body");
     });
     it("should define metadata for Header decorator", () => {
         const meta = Reflect.getMetadata(container_1.REQUEST_HEADER_META_KEY, TestController.prototype, "testMethod");
         expect(meta).toBeDefined();
-        expect(meta[3].key).toBe("x-token");
-        expect(meta[3].type).toBe("route:header");
+        expect(meta[0].key).toBe("x-token");
+        expect(meta[0].type).toBe("route:header");
     });
     it("should define metadata for AuthUser decorator", () => {
         const meta = Reflect.getMetadata(container_1.REQUEST_USER_META_KEY, TestController.prototype, "testMethod");
         expect(meta).toBeDefined();
-        expect(meta[4].key).toBe("all");
-        expect(meta[4].type).toBe("route:user");
+        expect(meta[0].key).toBe("all");
+        expect(meta[0].type).toBe("route:user");
     });
     it("should set required and validate options to true by default", () => {
         const meta = Reflect.getMetadata(container_1.PARAM_META_KEY, TestController.prototype, "testMethod");

package/dist/queue.d.ts

@@ -1,38 +1,29 @@
-import { EventEmitter } from "events";
-interface Job {
-    id: string;
-    data: any;
-    runAt?: number;
-    status?: "pending" | "running" | "failed" | "completed";
+import Bull, { Queue as BullQueue, Job, JobOptions } from 'bull';
+export interface QueueConfig {
+    name: string;
+    adapter?: any;
+    handler?: (job: Job) => Promise<any>;
+    options?: Bull.QueueOptions;
 }
-interface QueueAdapter {
-    loadJobs(): Promise<Job[]>;
-    saveJobs(jobs: Job[]): Promise<void>;
+export declare class AvleonQueue<T = any> {
+    protected name?: string | undefined;
+    protected adapter?: any | undefined;
+    protected queue: BullQueue<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(): BullQueue<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>[]>;
 }
-export declare class FileQueueAdapter implements QueueAdapter {
-    private queueFile;
-    constructor(queueName: string);
-    loadJobs(): Promise<Job[]>;
-    saveJobs(jobs: Job[]): Promise<void>;
-}
-export declare class AvleonQueue extends EventEmitter {
-    private name;
-    private processing;
-    private stopped;
-    private jobHandler;
-    private adapter;
-    constructor(name: string, adapter?: QueueAdapter, jobHandler?: (job: Job) => Promise<void>);
-    private defaultHandler;
-    addJob(data: any, options?: {
-        delay?: number;
-    }): Promise<void>;
-    private processNext;
-    onDone(cb: (job: Job) => void): Promise<void>;
-    onFailed(cb: (error: any, job: Job) => void): Promise<void>;
-    getJobs(): Promise<Job[]>;
-    stop(): Promise<void>;
-}
-export declare class QueueManager {
-    from(name: string, jobHandler?: (job: Job) => Promise<void>): Promise<AvleonQueue>;
-}
-export {};
+export declare function Queue(config: QueueConfig): <T extends {
+    new (...args: any[]): AvleonQueue;
+}>(target: T) => T;