@quan-erp/shared-backend-core 1.0.1

package/dist/types/abe2c417/8f79089f.d.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from "typeorm";
+export type ServiceProps<T> = {
+    manager?: EntityManager;
+} & T;
+export type CreateServiceProps<T> = ServiceProps<{
+    data: T;
+}>;
+export type GetByIdServiceProps = ServiceProps<{
+    id: number;
+}>;
+export type UpdateByIdServiceProps<T> = ServiceProps<{
+    id: number;
+    data: T;
+}>;
+export type DeleteByIdServiceProps = ServiceProps<{
+    id: number;
+}>;
+export type DeleteByIdServicePropsWithExternalProperties<E> = ServiceProps<{
+    id: number;
+} & E>;
+export type CreatedByUser = {
+    createdBy: number;
+};
+export type OptionalCreatedByUser = {
+    createdBy?: number;
+};

package/dist/types/abe2c417/a39169c6.d.ts

@@ -0,0 +1,308 @@
+/**
+ * ================= HASH FUNCTIONS FOR ENTITIES =================
+ *
+ * 1. hashEntity(entity: any): string
+ * ---------------------------------------------------------------
+ * - Generates a SHA-256 hash for any object or class instance.
+ * - Converts class instances to plain objects including prototype methods.
+ * - Recursively sorts object keys for deterministic output.
+ * - Sensitive to changes in property values and method code.
+ *
+ * Usage:
+ * - Suitable for general objects or class instances where you want to detect any change.
+ * - Can be used for caching, diffing, or content-based IDs.
+ *
+ * 2. safeHashEntity(entity: any): string
+ * ---------------------------------------------------------------
+ * - Generates a SHA-256 hash for objects or class instances in a "safe" way.
+ * - Handles circular references using WeakSet.
+ * - Serializes functions by their full code (spaces removed).
+ * - Includes both own properties and prototype methods.
+ *
+ * Usage:
+ * - Safe hashing for complex objects with circular references.
+ * - Suitable for general-purpose object comparison and caching where functions matter.
+ *
+ * 3. safeSoftHashEntity(entity: any): string
+ * ---------------------------------------------------------------
+ * - Generates a SHA-256 hash but ignores actual function code.
+ * - Functions are represented only by their name and number of declared parameters.
+ * - Ignores private fields (fields starting with '#').
+ * - Captures prototype method names and parameter counts (not implementation).
+ *
+ * Usage:
+ * - "Soft" structural hashing where function implementation changes should not affect hash.
+ * - Useful for versioning APIs, class structures, or database entity schema comparisons.
+ * - More stable and tolerant to minor implementation changes.
+ *
+ * 4. hashSoftDbEntityClass(cls: Function): string
+ * ---------------------------------------------------------------
+ * - Generates a SHA-256 hash specifically for TypeORM entity classes.
+ * - Includes entity metadata: columns, primary keys, relations, join columns, uniques, indices, checks.
+ * - Includes enum values for columns of type enum.
+ * - Ignores runtime values of instances; purely schema-based.
+ *
+ * Usage:
+ * - Ideal for detecting schema changes in database entities.
+ * - Can be used to detect structural changes in TypeORM models without touching the database.
+ * - More stable for migrations, schema versioning, or soft equality checks between entity classes.
+ *
+ *
+ *
+ *
+ *
+ * | Function Name            | What it Hashes                                  | Sensitivity / Notes                                                                 | Usage / When to Use                                                                                  |
+ * |--------------------------|-----------------------------------------------|------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
+ * | hashEntity               | Any object or class instance                  | Sensitive to property values and method code                                        | General objects or class instances, content-based IDs, caching, diffing                            |
+ * | safeHashEntity           | Any object or class instance (safe)          | Handles circular references, serializes functions by full code                      | Complex objects with circular references, comparison, caching where function code matters          |
+ * | safeSoftHashEntity       | Any object or class instance (soft)          | Ignores actual function code; uses function name + parameter count; ignores private fields | Structural / API / class versioning; stable across implementation changes                          |
+ * | hashSoftDbEntityClass    | TypeORM entity class metadata                | Includes columns, primary keys, relations, join columns, uniques, indices, checks; includes enum values | Detect schema changes in TypeORM models; migration tracking; soft equality of entity classes      |
+ *
+ *
+ *
+ */
+/**
+ * hashEntity
+ * --------------------------
+ * Generate a stable SHA-256 hash for any JavaScript object, class instance, or primitive.
+ *
+ * Features:
+ * 1. **Primitives**:
+ *    - Numbers, strings, booleans, null, and undefined are directly converted to string
+ *      (spaces removed) and hashed.
+ *
+ * 2. **Objects**:
+ *    - Plain objects are recursively traversed.
+ *    - Object keys are **sorted** to ensure deterministic output regardless of insertion order.
+ *    - Arrays are recursively processed without reordering elements.
+ *
+ * 3. **Class instances**:
+ *    - Converted to a plain object using `instanceToObject`.
+ *    - Includes both **own properties** (enumerable and non-enumerable) and
+ *      **prototype methods** (excluding constructor).
+ *    - Prototype methods are serialized as strings via `.toString()`.
+ *
+ * 4. **Stable hashing**:
+ *    - Sorting object keys and including prototype methods ensures that two
+ *      structurally identical entities produce the same hash.
+ *
+ * 5. **Hashing algorithm**:
+ *    - Uses SHA-256 and outputs a hexadecimal string.
+ *
+ * Example usage:
+ * ```ts
+ * class User {
+ *   id: number;
+ *   name: string;
+ *   greet(msg: string) { console.log(msg); }
+ * }
+ *
+ * const hash = hashEntity(User);
+ * console.log(hash); // deterministic hash of User's structure
+ * ```
+ *
+ * Notes:
+ * - Hash is **structure + method code sensitive**, so changes to function bodies will change the hash.
+ * - Suitable for comparing objects, entity classes, or instances for exact structural equivalence.
+ *
+ * @param entity - Object, class instance, or primitive to hash.
+ * @returns SHA-256 hexadecimal hash representing the entity.
+ */
+export declare function hashEntity(entity: any): string;
+/**
+ * safeHashEntity
+ * --------------------------
+ * Generates a stable, universal hash for a given JavaScript object, class instance, or function.
+ * Designed to handle complex structures, including nested objects, class prototypes, and circular references.
+ * Useful for comparing entity definitions, caching, or detecting structural changes.
+ *
+ * Features:
+ * 1. **Handles primitives and functions**:
+ *    - Primitives (string, number, boolean, null, undefined) are hashed directly.
+ *    - Functions are converted to their string representation (whitespace removed) for stable hashing.
+ *
+ * 2. **Traverses nested objects**:
+ *    - Recursively serializes all properties of objects.
+ *    - Handles circular references safely using a WeakSet (`[Circular]` placeholder).
+ *
+ * 3. **Includes prototype methods**:
+ *    - All non-constructor methods on the prototype chain (excluding `Object.prototype`) are serialized.
+ *    - Ensures class methods contribute to the hash, allowing detection of structural changes in classes.
+ *
+ * 4. **Error-resilient**:
+ *    - If a property cannot be accessed, a placeholder `[unreadable:<key>]` is stored.
+ *
+ * 5. **Stable JSON serialization**:
+ *    - Object keys are sorted before stringification to guarantee consistent hash output.
+ *
+ * 6. **SHA256 hash output**:
+ *    - Produces a 64-character hexadecimal SHA256 hash representing the full structure of the entity.
+ *
+ * Usage example:
+ * ```ts
+ * class MyEntity {
+ *   foo = 123;
+ *   bar() { return "hello"; }
+ * }
+ * const hash = safeHashEntity(MyEntity);
+ * console.log(hash); // stable hash string
+ * ```
+ *
+ * Notes:
+ * - Designed for **structural comparison**, not cryptographic security.
+ * - Ideal for TypeORM entities or other classes where schema or structure changes need tracking.
+ * - Can handle circular references safely.
+ *
+ * @param entity - The object, class, or instance to hash.
+ * @returns A stable SHA256 hash string representing the structure and methods of the input.
+ */
+export declare function safeHashEntity(entity: any): string;
+/**
+ * safeSoftHashEntity
+ * --------------------------
+ * Generates a "soft" or approximate hash for a JavaScript object, class instance, or function.
+ * Unlike a deep hash, this function only captures the **structure and shape** of an object,
+ * rather than exact values. Useful for detecting structural changes in entities, classes,
+ * or schemas without being sensitive to runtime data or minor value differences.
+ *
+ * Features:
+ * 1. **Primitives**:
+ *    - Numbers, strings, booleans, null, and undefined are returned directly.
+
+ * 2. **Functions**:
+ *    - Only function name and declared parameter count are considered.
+ *    - Ignores function body, default values, or closures.
+ *    - Represented as `{ __fn__: true, name: <name>, params: <number> }`.
+
+ * 3. **Objects**:
+ *    - Own enumerable and non-enumerable properties are included.
+ *    - Ignores private fields (those starting with `#`).
+ *    - Property values are replaced with `{ __prop__: true }` to capture structure, not content.
+
+ * 4. **Prototype methods**:
+ *    - Includes all non-constructor prototype functions.
+ *    - Ignores private methods (`#` prefixed).
+ *    - Captured as `__protoMethods__ = [{ name, params }]`.
+
+ * 5. **Circular references**:
+ *    - Safely handled using a `WeakSet`.
+ *    - Circular references are replaced with the string `[Circular]`.
+
+ * 6. **Stable serialization**:
+ *    - Object keys are sorted to guarantee a consistent hash regardless of property insertion order.
+ *    - JSON.stringify uses a custom replacer to enforce stable key ordering.
+
+ * 7. **Hashing**:
+ *    - Produces a 64-character SHA256 hexadecimal hash.
+ *    - Suitable for comparing entity shapes, class definitions, or object structures.
+
+ *
+ * Example usage:
+ * ```ts
+ * class User {
+ *   id: number;
+ *   name: string;
+ *   greet(msg: string) { console.log(msg); }
+ * }
+ *
+ * const hash = safeSoftHashEntity(User);
+ * console.log(hash); // stable structural hash
+ * ```
+ *
+ * Notes:
+ * - **Soft hash** ignores actual property values—only structure and function signatures matter.
+ * - Ideal for plugin system validation, or structural comparison.
+ * - Not meant for cryptographic security or detecting runtime data changes.
+ *
+ * @param entity - The object, class, or instance to hash structurally.
+ * @returns A SHA256 hexadecimal hash representing the structure of the input.
+ */
+export declare function safeSoftHashEntity(entity: any): string;
+/**
+ * hashSoftDbEntityClass
+ * --------------------------
+ * Generate a stable SHA-256 hash for a TypeORM entity class.
+ *
+ * This function inspects the entity class metadata from TypeORM's
+ * internal `getMetadataArgsStorage()` and builds a deterministic
+ * hash based on its structure and configuration.
+ *
+ * Features:
+ * 1. **Entity / Table**
+ *    - Table name, type (`regular` | `view` | `entity-child`), orderBy,
+ *      inheritance pattern, parent entity name.
+ *
+ * 2. **Columns**
+ *    - Includes column name, type, enum values, nullability, uniqueness,
+ *      length, width, precision, scale, default value, primary key flag,
+ *      generated strategy, transformer presence.
+ *
+ * 3. **Embedded columns**
+ *    - Includes property name, prefix, and type of embedded objects.
+ *
+ * 4. **Relations**
+ *    - Includes relation type (`OneToOne`, `ManyToOne`, `OneToMany`, `ManyToMany`),
+ *      target entity name, cascade, eager loading, nullable, onDelete/onUpdate behavior,
+ *      join columns, and join table info.
+ *
+ * 5. **Relation IDs and counts**
+ *    - Includes `@RelationId` and `@RelationCount` metadata.
+ *
+ * 6. **Unique constraints**
+ *    - All `@Unique` decorators are considered.
+ *    - Supports array or function-based column definitions.
+ *
+ * 7. **Indices**
+ *    - All `@Index` decorators are included.
+ *    - Supports array or function-based column definitions.
+ *    - Tracks spatial and fulltext flags for Postgres.
+ *
+ * 8. **Checks**
+ *    - Includes all `@Check` decorators with their expressions.
+ *
+ * 9. **Exclusions**
+ *    - Includes Postgres `@Exclusion` decorators and expressions.
+ *
+ * 10. **Tree metadata**
+ *     - Detects tree type (`closure-table`, `nested-set`, `materialized-path`).
+ *     - Tracks tree children, tree parent, and tree level columns.
+ *
+ * 11. **Views**
+ *     - Detects if entity is a `@ViewEntity`.
+ *     - Includes table name, view expression, and view columns with expressions.
+ *
+ * 12. **Entity listeners**
+ *     - Captures `@BeforeInsert`, `@AfterLoad`, etc., with property names.
+ *
+ * 13. **Deterministic output**
+ *     - Arrays and object keys are sorted consistently.
+ *     - Ensures that two entity classes with identical structures always produce the same hash.
+ *
+ * Use Cases:
+ * - Detect changes to entity structure without connecting to the database.
+ * - Useful for migration checks, versioning, plugin systems, or caching schemas.
+ *
+ * Example:
+ * ```ts
+ * @Entity()
+ * class User {
+ *   @PrimaryGeneratedColumn()
+ *   id: number;
+ *
+ *   @Column()
+ *   name: string;
+ * }
+ *
+ * const hash = hashSoftDbEntityClass(User);
+ * console.log(hash); // deterministic SHA-256 hash of User entity
+ * ```
+ *
+ * Notes:
+ * - Any change in column options, relations, indices, checks, tree structure,
+ *   view expression, or listeners will change the hash.
+ * - Enum value changes are included in the hash (`enumValues`).
+ *
+ * @param cls - TypeORM entity class constructor (Function)
+ * @returns SHA-256 hexadecimal hash representing the entity structure
+ */
+export declare function hashSoftDbEntityClass(cls: Function): string;

package/dist/types/abe2c417/b2732e39.d.ts

@@ -0,0 +1 @@
+export declare function getFolderSize(folder: string): Promise<number>;

package/dist/types/abe2c417/dc04a1bd.d.ts

@@ -0,0 +1,10 @@
+export declare function getAppDataFolder(): string | undefined;
+export declare function getAppTempDataFolder(): string;
+export declare function getPluginDataFolder(pluginName: string): string;
+export declare function getPluginAssetFolder(pluginName: string, version: string): string;
+export declare const AppFolder: {
+    getPluginAssetFolder: typeof getPluginAssetFolder;
+    getPluginDataFolder: typeof getPluginDataFolder;
+    getAppTempDataFolder: typeof getAppTempDataFolder;
+    getAppDataFolder: typeof getAppDataFolder;
+};

package/dist/types/abe2c417/e2fcc201.d.ts

@@ -0,0 +1,17 @@
+import jwt from "jsonwebtoken";
+export declare function signAccessToken(payload: object): string;
+export declare function signRefreshToken(payload: object): string;
+export declare function verifyAccessToken(token: string): {
+    valid: boolean;
+    payload: any;
+    error: any;
+};
+export declare function verifyRefreshToken(token: string, type?: 'raw-cookie' | 'token'): {
+    valid: boolean;
+    payload: string | jwt.JwtPayload;
+    error?: undefined;
+} | {
+    valid: boolean;
+    error: unknown;
+    payload?: undefined;
+};

package/dist/types/abe2c417/e7055140.d.ts

@@ -0,0 +1 @@
+export declare function waitFor(duration?: number): Promise<unknown>;

package/dist/types/abe2c417/ee24e24a.d.ts

@@ -0,0 +1 @@
+export declare function isClass(value: any): boolean;

package/dist/types/abe2c417/ef5d95cf.d.ts

@@ -0,0 +1,44 @@
+type NestedStringRecord = {
+    [key: string]: string | NestedStringRecord;
+};
+type MappedNestedStringRecord<T> = {
+    [K in keyof T]: T[K] extends string ? string : T[K] extends NestedStringRecord ? MappedNestedStringRecord<T[K]> : never;
+};
+export declare function buildCacheKeys<T extends NestedStringRecord>(props: {
+    prefix: string;
+    type: 'controller' | 'service';
+    keys: T;
+}): MappedNestedStringRecord<T>;
+export declare const CORE_CONTROLLER_CACHE_KEYS: MappedNestedStringRecord<{
+    USER: string;
+    ROLE: string;
+    ROLE_BY_USER: string;
+    PERMISSION: string;
+    PERMISSION_ROLE: string;
+    API_DOCS: string;
+    AUDIT_LOG: string;
+    AI_ASSISTANT: string;
+    AI_MODEL: string;
+    AI_TOOL: string;
+    DATA_GRID: string;
+}>;
+export declare const CORE_SERVICE_CACHE_KEYS: MappedNestedStringRecord<{
+    ENV: string;
+    USER: string;
+}>;
+export declare const CONTROLLER_CACHE_KEYS: MappedNestedStringRecord<{
+    UOC: string;
+    UOM: string;
+    UNIT_CATEGORY: string;
+    TAG: string;
+    NOTIFICATION: string;
+    DEVELOPER_CONFIG: string;
+    CURRENCY_EXCHANGE: string;
+    CURRENCY: string;
+    BRANCH: string;
+    PARTNER: string;
+}>;
+export declare const SERVICE_CACHE_KEYS: MappedNestedStringRecord<{
+    CHANGE_LOG: string;
+}>;
+export {};

package/dist/types/abe2c417/f7f8ce4e.d.ts

@@ -0,0 +1,9 @@
+export declare class Version {
+    /**
+     * Check if an installed version satisfies the required version
+     * @param installedVersion - version of the installed plugin, e.g., "0.0.1"
+     * @param requiredVersion - version requirement, e.g., "^1.0.0"
+     * @returns boolean
+     */
+    static checkVersion(installedVersion: string, requiredVersion: string): boolean;
+}

package/dist/types/abe2c417/f9ceab53.d.ts

@@ -0,0 +1,50 @@
+export declare enum HttpStatus {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    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,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}

package/dist/types/b7ca7461.d.ts

@@ -0,0 +1,18 @@
+export declare function backupDB({ dbName, user, password, host, // database container name
+port, backupFile }?: {
+    dbName?: string | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    backupFile?: string | undefined;
+}): Promise<unknown>;
+export declare function importDB({ dbName, user, password, host, // database container name
+port, backupFile }?: {
+    dbName?: string | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    backupFile?: string | undefined;
+}): Promise<unknown>;

package/dist/types/d58efc4e/0bb17e35.d.ts

@@ -0,0 +1,2 @@
+import { InitialMigrations } from "./9f2ae4fe.js";
+export declare const BuiltinMigrations: (typeof InitialMigrations)[];

package/dist/types/d58efc4e/9f2ae4fe.d.ts

@@ -0,0 +1,11 @@
+import { IDatabaseMigration } from '@quan-erp/shared-types';
+import { QueryRunner } from 'typeorm';
+export declare class InitialMigrations implements IDatabaseMigration {
+    getName(): string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+    getSource(): {
+        plugin: string;
+        name: string;
+    };
+}

package/dist/types/d58efc4e/b8cff974.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { DataSource } from "typeorm";
+export declare const AppDataSource: DataSource;

package/dist/types/fbc6c1d4/80614691.d.ts

@@ -0,0 +1,23 @@
+import { DataSource } from "typeorm";
+export type KeyStore = {
+    [key: string]: any;
+    [key: number]: any;
+};
+export interface AppContext {
+    get(name: string): void;
+    set<T>(name: string, value: T): void;
+    getDatabase(): DatabaseDetail;
+}
+export interface DatabaseDetail {
+    registerEntity(entities: any[]): void;
+    getDataSource(): DataSource | null;
+}
+export declare class Context implements AppContext {
+    private store;
+    private readonly datasource?;
+    private readonly queue?;
+    constructor(datasource?: DataSource, queue?: any);
+    get(name: string): any;
+    set<T>(name: string, value: T): void;
+    getDatabase(): DatabaseDetail;
+}

package/dist/types/fd7f274b/0daaeab3.d.ts

@@ -0,0 +1,5 @@
+export * from "./272670be.js";
+export * from "./396495ab.js";
+export * from "./3c41945d.js";
+export * from "./4f9e1401.js";
+export { CheckAPIPermission } from "./83451de8.js";

package/dist/types/fd7f274b/116d81bf.d.ts

@@ -0,0 +1 @@
+export declare function UatOnly(): ClassDecorator & MethodDecorator;

package/dist/types/fd7f274b/272670be.d.ts

@@ -0,0 +1 @@
+export declare function AuthenticatedUserOnly(): MethodDecorator & ClassDecorator;

package/dist/types/fd7f274b/396495ab.d.ts

@@ -0,0 +1 @@
+export declare function DevelopmentOnly(): ClassDecorator & MethodDecorator;

package/dist/types/fd7f274b/3c41945d.d.ts

@@ -0,0 +1 @@
+export declare function OwnerOnly(): ClassDecorator & MethodDecorator;

package/dist/types/fd7f274b/41af1e6f.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Decorator to validate request bodies against a specified DTO class.
+ * Can be applied to a controller class (all routes) or individual route methods.
+ *
+ * @param {new (...args: any[]) => any} DTOClass - The class to use for validation.
+ *        Must be a class decorated with class-validator decorators.
+ *
+ * @returns {MethodDecorator & ClassDecorator} A decorator that applies validation middleware
+ *          before the route handler executes.
+ *
+ * @example
+ * ```ts
+ * import { IsString, IsEmail } from 'class-validator';
+ *
+ * class CreateUserDTO {
+ *   @IsString()
+ *   name: string;
+ *
+ *   @IsEmail()
+ *   email: string;
+ * }
+ *
+ * @Validate(CreateUserDTO)
+ * class UserController {
+ *   create(req: Request, res: Response) {
+ *     // req.body is now a validated CreateUserDTO instance
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * - Uses `class-transformer` to convert plain object into DTO instance.
+ * - Responds with HTTP 400 if validation fails, including the list of property errors.
+ * - Replaces `req.body` with the validated DTO instance.
+ * - Responds with HTTP 500 if an unexpected error occurs during validation.
+ * - Internally uses the `Middleware` decorator with `MiddlewarePosition.BEFORE_ROUTE`.
+ */
+export declare function Validate(DTOClass: new (...args: any[]) => any, callback: (body: any) => any): MethodDecorator & ClassDecorator;

package/dist/types/fd7f274b/4f9e1401.d.ts

@@ -0,0 +1,4 @@
+import express from 'express';
+type Handler = (req: express.Request) => string;
+export declare function AuditLogMiddleware(action: string | Handler): ClassDecorator & MethodDecorator;
+export {};

package/dist/types/fd7f274b/6a4e3ffe.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from "express";
+import { IExpressMiddleware } from "../0d45f5fd/6559a8c1.js";
+import { Loggable } from "../0d45f5fd/4dd6b41d.js";
+import { APIAccessTokenService } from "../6610c73e/2882bf13/5a5d4923.js";
+export declare class ResolveUserMiddleware implements IExpressMiddleware {
+    logger: Loggable;
+    apiAccessTokenService: APIAccessTokenService;
+    handler(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/types/fd7f274b/6d8bea2a.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response, NextFunction } from "express";
+import { IExpressMiddleware } from "../0d45f5fd/6559a8c1.js";
+import { DeveloperConfigService } from "../2ad56231/ceaf7c2a.js";
+import { Loggable } from "../0d45f5fd/4dd6b41d.js";
+export declare class SubscriptionMiddleware implements IExpressMiddleware {
+    developerConfigService: DeveloperConfigService;
+    logger: Loggable;
+    handler(req: Request, res: Response, next: NextFunction): Promise<void>;
+}
+export declare function isSubscriptionExpired(expireDate?: Date, graceDays?: number): boolean;

package/dist/types/fd7f274b/83451de8.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response, NextFunction } from "express";
+import { IExpressMiddleware } from "../0d45f5fd/6559a8c1.js";
+import { Loggable } from "../0d45f5fd/4dd6b41d.js";
+export declare class ApiPermissionMiddlewareFilter implements IExpressMiddleware {
+    logger: Loggable;
+    private permissionService;
+    private temporaryAPIAccessService;
+    private get app();
+    handler(req: Request, res: Response, next: NextFunction): Promise<void | Response<any, Record<string, any>>>;
+    private isPreflight;
+}
+export declare function CheckAPIPermission(): ClassDecorator & MethodDecorator;

package/dist/types/fd7f274b/c5ce5c8f.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response, NextFunction } from "express";
+import { IExpressMiddleware } from "../0d45f5fd/6559a8c1.js";
+import { Loggable } from "../0d45f5fd/4dd6b41d.js";
+import { AuditLogService } from "../6610c73e/108201be/c917408b.js";
+import { GracefulJobManager } from "../0d45f5fd/496c2854.js";
+export declare class APILogMiddleware implements IExpressMiddleware {
+    logger: Loggable;
+    service: AuditLogService;
+    graceful: GracefulJobManager;
+    handler(req: Request, res: Response, next: NextFunction): void;
+}