@flusys/nestjs-shared 1.1.0-beta → 2.0.0

package/cjs/modules/utils/utils.service.js

@@ -9,247 +9,84 @@ Object.defineProperty(exports, "UtilsService", {
     }
 });
 const _common = require("@nestjs/common");
-const _classvalidator = require("class-validator");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
 let UtilsService = class UtilsService {
     // ---------------- CACHE HELPERS ----------------
     /**
    * Generate cache key with optional tenant prefix for multi-tenant isolation
-   * @param entityName - Name of the entity being cached
-   * @param params - Query parameters for cache key uniqueness
-   * @param entityId - Optional entity ID for single entity caching
-   * @param tenantId - Optional tenant ID for multi-tenant isolation
    */ getCacheKey(entityName, params, entityId, tenantId) {
-        const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
-        if (entityId) return `${tenantPrefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
-        return `${tenantPrefix}entity_${entityName}_all_${JSON.stringify(params)}`;
+        const prefix = this.buildTenantPrefix(tenantId);
+        if (entityId) {
+            return `${prefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
+        }
+        return `${prefix}entity_${entityName}_all_${JSON.stringify(params)}`;
     }
     /**
    * Track cache key for later invalidation with optional tenant prefix
    */ async trackCacheKey(cacheKey, entityName, cacheManager, entityId, tenantId) {
-        const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
         try {
-            if (entityId) {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_id_${entityId}_keys`;
-                const idKeys = await cacheManager.get(trackingKey) || [];
-                if (!idKeys.includes(cacheKey)) idKeys.push(cacheKey);
-                await cacheManager.set(trackingKey, idKeys);
-            } else {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_keys`;
-                const allKeys = await cacheManager.get(trackingKey) || [];
-                if (!allKeys.includes(cacheKey)) allKeys.push(cacheKey);
-                await cacheManager.set(trackingKey, allKeys);
-            }
+            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
+            const keys = await cacheManager.get(trackingKey) || [];
+            if (!keys.includes(cacheKey)) keys.push(cacheKey);
+            await cacheManager.set(trackingKey, keys);
         } catch (error) {
-            // Log but don't throw - cache tracking failure shouldn't break the request
-            console.error(`Cache tracking failed for ${entityName}:`, error);
+            this.logger.error(`Cache tracking failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
         }
     }
     /**
    * Clear cache for entity with optional tenant prefix
-   * Uses Promise.allSettled to ensure all deletions are attempted even if some fail
    */ async clearCache(entityName, cacheManager, entityId, tenantId) {
-        const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
         try {
-            if (entityId) {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_id_${entityId}_keys`;
-                const idKeys = await cacheManager.get(trackingKey) || [];
-                // Use Promise.allSettled to ensure all deletions are attempted
-                await Promise.allSettled(idKeys.map((key)=>cacheManager.del(key)));
-                await cacheManager.del(trackingKey);
-            } else {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_keys`;
-                const keySet = await cacheManager.get(trackingKey) || [];
-                // Use Promise.allSettled to ensure all deletions are attempted
-                await Promise.allSettled(keySet.map((key)=>cacheManager.del(key)));
-                await cacheManager.del(trackingKey);
-            }
+            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
+            const keys = await cacheManager.get(trackingKey) || [];
+            await Promise.allSettled(keys.map((key)=>cacheManager.del(key)));
+            await cacheManager.del(trackingKey);
         } catch (error) {
-            // Log but don't throw - cache invalidation failure shouldn't break the request
-            console.error(`Cache invalidation failed for ${entityName}:`, error);
-        }
-    }
-    /**
-   * Check Phone or Email
-   */ checkPhoneOrEmail(value) {
-        if ((0, _classvalidator.isEmail)(value)) {
-            return {
-                value: value,
-                type: 'email'
-            };
-        }
-        const phoneMatch = value.match(/^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/);
-        if (phoneMatch) {
-            let phone = phoneMatch[0];
-            if (!phone.startsWith('+88')) {
-                phone = '+88' + phone;
-            }
-            return {
-                value: phone,
-                type: 'phone'
-            };
+            this.logger.error(`Cache invalidation failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
         }
-        return {
-            value: null,
-            type: null
-        };
     }
+    // ---------------- STRING HELPERS ----------------
     /**
-   * STRING FUNCTIONS
-   * transformToSlug
+   * Transform string to URL-friendly slug
    */ transformToSlug(value, salt) {
         const slug = value?.trim().replace(/[^A-Z0-9]+/gi, '-').toLowerCase();
         return salt ? `${slug}-${this.getRandomInt(1, 100)}` : slug;
     }
     /**
-   * RANDOM FUNCTIONS
-   * getRandomInt
-   * generateRandomId
-   * getRandomOtpCode
+   * Generate random integer between min and max (inclusive)
    */ getRandomInt(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
-    generateRandomId(length) {
-        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        let result = '';
-        for(let i = 0; i < length; i++){
-            result += characters.charAt(Math.floor(Math.random() * characters.length));
-        }
-        return result;
-    }
-    getRandomOtpCode() {
-        return Math.floor(Math.random() * (9999 - 1000 + 1)) + 1000;
+    // ---------------- PRIVATE HELPERS ----------------
+    buildTenantPrefix(tenantId) {
+        return tenantId ? `tenant_${tenantId}_` : '';
     }
-    extractColumnNameFromError(detail) {
-        const match = detail.match(/\((.*?)\)=\((.*?)\)/);
-        return {
-            columnName: match ? match[1] : 'unknown',
-            value: match ? match[2] : 'unknown'
-        };
-    }
-    getOtpEmailFormat(otp, userName) {
-        return `
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-      <meta charset="UTF-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-      <title>Your OTP Code</title>
-      <style>
-        body {
-          font-family: Arial, sans-serif;
-          background-color: #f4f4f7;
-          margin: 0;
-          padding: 0;
-        }
-        .email-container {
-          max-width: 500px;
-          margin: 40px auto;
-          background-color: #ffffff;
-          padding: 30px;
-          border-radius: 8px;
-          box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
-          text-align: center;
-        }
-        h1 {
-          color: #333;
-        }
-        p {
-          font-size: 16px;
-          color: #555;
-        }
-        .otp-box {
-          display: inline-block;
-          margin: 20px 0;
-          padding: 14px 28px;
-          font-size: 24px;
-          letter-spacing: 6px;
-          background-color: #007BFF;
-          color: white;
-          border-radius: 8px;
-          font-weight: bold;
-        }
-      </style>
-    </head>
-    <body>
-      <div class="email-container">
-        <p>Hi ${userName || 'Sir/Madam'},</p>
-        <p>Use the code below to verify your identity:</p>
-        <div class="otp-box">${otp}</div>
-        <p>This OTP is valid for a limited time. Do not share it with anyone.</p>
-        <p>If you didn’t request this, please ignore this email.</p>
-      </div>
-    </body>
-    </html>
-  `;
+    buildTrackingKey(entityName, entityId, tenantId) {
+        const prefix = this.buildTenantPrefix(tenantId);
+        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
     }
-    getResetPasswordEmailFormat(resetLink, userName) {
-        return `
-  <!DOCTYPE html>
-  <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-    <title>Reset Your Password</title>
-    <style>
-      body {
-        font-family: Arial, sans-serif;
-        background-color: #f4f4f7;
-        margin: 0;
-        padding: 0;
-      }
-      .email-container {
-        max-width: 500px;
-        margin: 40px auto;
-        background-color: #ffffff;
-        padding: 30px;
-        border-radius: 8px;
-        box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
-        text-align: center;
-      }
-      h1 {
-        color: #333;
-      }
-      p {
-        font-size: 16px;
-        color: #555;
-      }
-      .reset-button {
-        display: inline-block;
-        margin: 20px 0;
-        padding: 14px 28px;
-        font-size: 16px;
-        background-color: #007BFF;
-        color: #ffffff !important;
-        text-decoration: none;
-        border-radius: 6px;
-        font-weight: bold;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="email-container">
-      <p>Hi ${userName || 'Sir/Madam'},</p>
-      <p>We received a request to reset your password. Click the button below to reset it:</p>
-      <a href="${resetLink}" class="reset-button" target="_blank">Reset Password</a>
-      <p>If you didn’t request a password reset, you can safely ignore this email.</p>
-    </div>
-  </body>
-  </html>
-  `;
+    constructor(){
+        _define_property(this, "logger", new _common.Logger(UtilsService.name));
     }
-    constructor(){}
 };
 UtilsService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [])
+    (0, _common.Injectable)()
 ], UtilsService);

package/cjs/utils/error-handler.util.js

@@ -8,9 +8,17 @@ Object.defineProperty(exports, "ErrorHandler", {
         return ErrorHandler;
     }
 });
+/** Sensitive keys that should be redacted from logs */ const SENSITIVE_KEYS = [
+    'password',
+    'secret',
+    'token',
+    'apiKey',
+    'credential',
+    'authorization'
+];
 let ErrorHandler = class ErrorHandler {
     /**
-   * Safely extract error message from unknown error
+   * Safely extract error message from unknown error.
    */ static getErrorMessage(error) {
         if (error instanceof Error) {
             return error.message;
@@ -21,15 +29,25 @@ let ErrorHandler = class ErrorHandler {
         return 'Unknown error occurred';
     }
     /**
-   * Safely extract error stack from unknown error
-   */ static getErrorStack(error) {
-        if (error instanceof Error) {
-            return error.stack;
+   * Sanitize context data to redact sensitive fields from logs.
+   */ static sanitizeContextForLogging(context) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(context)){
+            const isSensitive = SENSITIVE_KEYS.some((sk)=>key.toLowerCase().includes(sk.toLowerCase()));
+            if (isSensitive) {
+                sanitized[key] = '[REDACTED]';
+            } else if (Array.isArray(value)) {
+                sanitized[key] = value.map((item)=>typeof item === 'object' && item !== null ? this.sanitizeContextForLogging(item) : item);
+            } else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitizeContextForLogging(value);
+            } else {
+                sanitized[key] = value;
+            }
         }
-        return undefined;
+        return sanitized;
     }
     /**
-   * Create error context object for logging
+   * Create error context object for internal logging.
    */ static createErrorContext(error, context) {
         const errorContext = {
             error: {
@@ -41,27 +59,32 @@ let ErrorHandler = class ErrorHandler {
             errorContext.error.name = error.name;
         }
         if (context && Object.keys(context).length > 0) {
-            errorContext.context = context;
+            errorContext.context = this.sanitizeContextForLogging(context);
         }
         return errorContext;
     }
     /**
-   * Log error with consistent format
+   * Log error with consistent format.
    */ static logError(logger, error, operation, context) {
         const errorContext = this.createErrorContext(error, {
             operation,
             ...context
         });
         const errorMessage = `Failed to ${operation}: ${errorContext.error.message}`;
-        const loggerContext = logger.context || 'ErrorHandler';
-        logger.error(errorMessage, errorContext.error.stack, loggerContext, errorContext);
+        logger.error(errorMessage, errorContext.error.stack, errorContext);
     }
     /**
-   * Re-throw error with proper type checking
+   * Re-throw error with proper type checking.
    */ static rethrowError(error) {
         if (error instanceof Error) {
             throw error;
         }
         throw new Error(`Unexpected error: ${String(error)}`);
     }
+    /**
+   * Log error and re-throw (common pattern).
+   */ static logAndRethrow(logger, error, operation, context) {
+        this.logError(logger, error, operation, context);
+        this.rethrowError(error);
+    }
 };

package/cjs/utils/html-sanitizer.util.js

@@ -0,0 +1,64 @@
+/**
+ * HTML Sanitizer Utilities
+ *
+ * Provides functions for escaping HTML content to prevent XSS attacks.
+ * Use these utilities when interpolating user-provided variables into HTML content.
+ */ /**
+ * HTML entity mapping for escaping special characters
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get escapeHtml () {
+        return escapeHtml;
+    },
+    get escapeHtmlVariables () {
+        return escapeHtmlVariables;
+    }
+});
+const HTML_ESCAPE_MAP = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+    '/': '&#x2F;',
+    '`': '&#x60;',
+    '=': '&#x3D;'
+};
+/**
+ * Regex pattern matching characters that need HTML escaping
+ */ const HTML_ESCAPE_REGEX = /[&<>"'`=/]/g;
+function escapeHtml(str) {
+    if (!str || typeof str !== 'string') {
+        return str ?? '';
+    }
+    return str.replace(HTML_ESCAPE_REGEX, (char)=>HTML_ESCAPE_MAP[char]);
+}
+function escapeHtmlVariables(variables) {
+    if (!variables || typeof variables !== 'object') {
+        return {};
+    }
+    const escaped = {};
+    for (const [key, value] of Object.entries(variables)){
+        if (value === null || value === undefined) {
+            escaped[key] = '';
+        } else if (typeof value === 'string') {
+            escaped[key] = escapeHtml(value);
+        } else if (typeof value === 'object') {
+            // For objects/arrays, stringify and escape
+            escaped[key] = escapeHtml(JSON.stringify(value));
+        } else {
+            // For numbers, booleans, etc., convert to string (no escaping needed)
+            escaped[key] = String(value);
+        }
+    }
+    return escaped;
+}

package/cjs/utils/index.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./error-handler.util"), exports);
+_export_star(require("./html-sanitizer.util"), exports);
+_export_star(require("./query-helpers.util"), exports);
+_export_star(require("./request.util"), exports);
+_export_star(require("./string.util"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/cjs/utils/query-helpers.util.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get applyCompanyFilter () {
+        return applyCompanyFilter;
+    },
+    get buildCompanyWhereCondition () {
+        return buildCompanyWhereCondition;
+    },
+    get hasCompanyId () {
+        return hasCompanyId;
+    },
+    get validateCompanyOwnership () {
+        return validateCompanyOwnership;
+    }
+});
+const _common = require("@nestjs/common");
+function applyCompanyFilter(query, config, user) {
+    const columnName = config.columnName ?? 'companyId';
+    if (config.isCompanyFeatureEnabled && user?.companyId) {
+        query.andWhere(`${config.entityAlias}.${columnName} = :companyId`, {
+            companyId: user.companyId
+        });
+    }
+    return query;
+}
+function buildCompanyWhereCondition(baseWhere, isCompanyFeatureEnabled, user) {
+    if (isCompanyFeatureEnabled && user?.companyId) {
+        return {
+            ...baseWhere,
+            companyId: user.companyId
+        };
+    }
+    return baseWhere;
+}
+function hasCompanyId(entity) {
+    return entity !== null && typeof entity === 'object' && 'companyId' in entity;
+}
+function validateCompanyOwnership(entity, user, isCompanyFeatureEnabled, entityName) {
+    if (isCompanyFeatureEnabled && user?.companyId && hasCompanyId(entity)) {
+        if (entity.companyId && entity.companyId !== user.companyId) {
+            throw new _common.BadRequestException(`${entityName} belongs to another company`);
+        }
+    }
+}

package/cjs/utils/request.util.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get buildCookieOptions () {
+        return buildCookieOptions;
+    },
+    get isBrowserRequest () {
+        return isBrowserRequest;
+    },
+    get parseDurationToMs () {
+        return parseDurationToMs;
+    }
+});
+const _constants = require("../constants");
+/** Time unit multipliers in milliseconds */ const TIME_UNIT_MS = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000
+};
+/** Get normalized client type from request header */ function getClientType(req) {
+    const clientType = req.headers[_constants.CLIENT_TYPE_HEADER];
+    return clientType ? clientType.toLowerCase() : null;
+}
+function isBrowserRequest(req) {
+    const clientType = getClientType(req);
+    if (clientType) {
+        return clientType === 'browser' || clientType === 'web';
+    }
+    const accept = req.headers['accept'] || '';
+    if (accept.includes('text/html')) return true;
+    const userAgent = req.headers['user-agent'] || '';
+    const browserPatterns = /mozilla|chrome|safari|firefox|edge|opera|msie/i;
+    return browserPatterns.test(userAgent) && !userAgent.includes('Postman');
+}
+function buildCookieOptions(req) {
+    const hostname = req.hostname || '';
+    const origin = req.headers.origin || '';
+    const isProduction = process.env.NODE_ENV === 'production';
+    const forwardedProto = req.headers['x-forwarded-proto'];
+    const isHttps = isProduction || forwardedProto === 'https' || origin.startsWith('https://') || req.secure;
+    let domain;
+    const domainParts = hostname.split('.');
+    if (domainParts.length > 2 && !hostname.includes('localhost')) {
+        domain = '.' + domainParts.slice(-2).join('.');
+    }
+    return {
+        secure: isHttps,
+        sameSite: isHttps ? 'strict' : 'lax',
+        ...domain && {
+            domain
+        }
+    };
+}
+function parseDurationToMs(duration, defaultMs = TIME_UNIT_MS.w) {
+    const match = duration.match(/^(\d+)(s|m|h|d|w)$/);
+    if (!match) return defaultMs;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    return value * (TIME_UNIT_MS[unit] ?? TIME_UNIT_MS.d);
+}

package/cjs/utils/string.util.js

@@ -0,0 +1,63 @@
+/**
+ * String utility functions
+ */ /**
+ * Generate URL-friendly slug from a string
+ * @param text - The text to convert to slug
+ * @param maxLength - Maximum length of the slug (default: 100)
+ * @returns URL-friendly slug
+ *
+ * @example
+ * generateSlug('My Company Name') // 'my-company-name'
+ * generateSlug('Hello World!') // 'hello-world'
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generateSlug () {
+        return generateSlug;
+    },
+    get generateUniqueSlug () {
+        return generateUniqueSlug;
+    }
+});
+function generateSlug(text, maxLength = 100) {
+    return text.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, '') // Remove special characters
+    .replace(/\s+/g, '-') // Replace spaces with hyphens
+    .replace(/-+/g, '-') // Replace multiple hyphens with single
+    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+    .substring(0, maxLength);
+}
+async function generateUniqueSlug(text, findMatchingSlugs, maxLength = 100) {
+    const baseSlug = generateSlug(text, maxLength);
+    // Single query to get all matching slugs
+    const existingSlugs = await findMatchingSlugs(baseSlug);
+    // No collisions - base slug is available
+    if (existingSlugs.length === 0) {
+        return baseSlug;
+    }
+    // Build set for O(1) lookup
+    const existingSet = new Set(existingSlugs);
+    // Base slug not taken (only suffixed versions exist)
+    if (!existingSet.has(baseSlug)) {
+        return baseSlug;
+    }
+    // Find next available suffix in memory (fast)
+    let counter = 1;
+    while(counter < 10000){
+        const slugWithSuffix = `${baseSlug}-${counter}`;
+        if (!existingSet.has(slugWithSuffix)) {
+            return slugWithSuffix;
+        }
+        counter++;
+    }
+    // Fallback: append random string (extremely rare edge case)
+    const randomSuffix = Math.random().toString(36).substring(2, 8);
+    return `${baseSlug}-${randomSuffix}`;
+}

package/classes/api-controller.class.d.ts

@@ -1,6 +1,6 @@
-import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
-import { Identity } from '@flusys/nestjs-shared/entities';
-import { ILoggedUserInfo, IService, PermissionCondition, PermissionOperator } from '@flusys/nestjs-shared/interfaces';
+import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '../dtos';
+import { Identity } from '../entities';
+import { ILoggedUserInfo, IService, PermissionCondition, PermissionOperator } from '../interfaces';
 import { Type } from '@nestjs/common';
 export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getAll' | 'update' | 'updateMany' | 'delete';
 export type SecurityLevel = 'public' | 'jwt' | 'permission';
@@ -16,9 +16,9 @@ export type ApiSecurityConfig = {
 export interface ApiControllerOptions {
     security?: ApiSecurityConfig | EndpointSecurity | SecurityLevel;
 }
-export declare function createApiController<CreateDtoT extends Record<string, unknown>, UpdateDtoT extends {
+export declare function createApiController<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
-}, ResponseDtoT extends Record<string, unknown>, InterfaceT extends Identity, ServiceT extends IService<CreateDtoT, UpdateDtoT, InterfaceT>>(createDtoClass: Type<CreateDtoT>, updateDtoClass: Type<UpdateDtoT>, responseDtoClass: Type<ResponseDtoT>, options?: ApiControllerOptions): abstract new (service: ServiceT) => {
+}, ResponseDtoT extends object, InterfaceT extends Identity, ServiceT extends IService<CreateDtoT, UpdateDtoT, InterfaceT>>(createDtoClass: Type<CreateDtoT>, updateDtoClass: Type<UpdateDtoT>, responseDtoClass: Type<ResponseDtoT>, options?: ApiControllerOptions): abstract new (service: ServiceT) => {
     service: ServiceT;
     insert(addDto: CreateDtoT, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     insertMany(addDto: CreateDtoT[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;