@noony-serverless/core 0.2.1 → 0.3.0

package/build/core/handler.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Handler = void 0;
-// Container import for direct container creation (no pooling needed)
-const typedi_1 = __importDefault(require("typedi"));
+// Container import removed - now using containerPool for performance
 const core_1 = require("./core");
+const containerPool_1 = require("./containerPool");
 /**
  * The Handler class is responsible for managing and executing middleware functions
  * and a main handler function in a sequential and controlled manner.
@@ -15,8 +12,6 @@ const core_1 = require("./core");
  * process a request/response flow either before the main handler (via `before`),
  * after the main handler (via `after`), or handle errors (via `onError`).
  *
- * @example
- * ```typescript
  * interface MessagePayload {
  *   action: string;
  *   data: Record<string, unknown>;
@@ -27,10 +22,10 @@ const core_1 = require("./core");
  *   .use(bodyParser())
  *   .handle(async (context) => {
  *     const { req } = context;
- *     // Handle the request with type-safe access to req.validatedBody
+ *     // Handle the request
  *   });
- * ```
  * @template T Type for the input request data.
+ * @template U Type for the additional context or response data.
  */
 class Handler {
     baseMiddlewares = [];
@@ -45,9 +40,12 @@ class Handler {
         return handler;
     }
     use(middleware) {
-        // Simple middleware chaining without complex type transformations
-        this.baseMiddlewares.push(middleware);
-        return this;
+        const handler = new Handler();
+        handler.baseMiddlewares = [
+            ...this.baseMiddlewares,
+            middleware,
+        ];
+        return handler;
     }
     handle(handler) {
         this.handler = handler;
@@ -65,17 +63,12 @@ class Handler {
         this.errorMiddlewares = this.reversedMiddlewares.filter((m) => m.onError);
         this.middlewaresPrecomputed = true;
     }
-    /**
-     * Universal execute method that works with any HTTP framework
-     * Automatically detects and adapts GCP, Express, AWS Lambda, Fastify, etc.
-     */
-    async execute(nativeReq, nativeRes) {
-        // Smart universal adapter - convert any framework's request/response to Noony format
-        const req = this.adaptToNoonyRequest(nativeReq);
-        const res = this.adaptToNoonyResponse(nativeRes, nativeReq);
-        // Direct container creation - simpler and appropriate for serverless
-        const container = typedi_1.default.of();
-        const context = (0, core_1.createContext)(req, res, {
+    async execute(req, res) {
+        const genericReq = (0, core_1.adaptGCPRequest)(req);
+        const genericRes = (0, core_1.adaptGCPResponse)(res);
+        // Performance optimization: Use container pool instead of creating new containers
+        const container = containerPool_1.containerPool.acquire();
+        const context = (0, core_1.createContext)(genericReq, genericRes, {
             container,
         });
         try {
@@ -90,7 +83,10 @@ class Handler {
             // Execute error handlers using pre-computed array
             await this.executeErrorMiddlewares(error, context);
         }
-        // No cleanup needed - container will be garbage collected automatically
+        finally {
+            // Always return container to pool for reuse
+            containerPool_1.containerPool.release(container);
+        }
     }
     /**
      * Execute before middlewares with optimized batching for independent middlewares
@@ -125,115 +121,30 @@ class Handler {
         }
     }
     /**
-     * Universal request adapter - converts any framework's request to NoonyRequest
-     */
-    adaptToNoonyRequest(nativeReq) {
-        const req = nativeReq;
-        // Universal property mapping that works with any HTTP framework
-        return {
-            method: req.method || req.httpMethod || core_1.HttpMethod.GET,
-            url: req.url || req.originalUrl || req.path || '/',
-            path: req.path || req.resource,
-            headers: req.headers || {},
-            query: req.query || req.queryStringParameters || {},
-            params: req.params || req.pathParameters || {},
-            body: req.body,
-            rawBody: req.rawBody || req.body,
-            parsedBody: req.parsedBody,
-            validatedBody: req.validatedBody,
-            ip: req.ip || req.requestContext?.identity?.sourceIp,
-            userAgent: (typeof req.headers?.['user-agent'] === 'string'
-                ? req.headers['user-agent']
-                : Array.isArray(req.headers?.['user-agent'])
-                    ? req.headers['user-agent'][0]
-                    : undefined) || req.get?.('user-agent'),
-        };
-    }
-    /**
-     * Universal response adapter - converts any framework's response to NoonyResponse
-     */
-    adaptToNoonyResponse(nativeRes, nativeReq) {
-        const req = nativeReq;
-        // Detect AWS Lambda pattern (different from standard HTTP)
-        if (req?.requestContext && typeof nativeRes === 'function') {
-            return this.createAWSLambdaResponse(nativeRes);
-        }
-        // Standard HTTP response (GCP, Express, Fastify, etc.)
-        return this.createStandardHTTPResponse(nativeRes);
-    }
-    /**
-     * Create response adapter for AWS Lambda
-     */
-    createAWSLambdaResponse(lambdaCallback) {
-        let statusCode = 200;
-        const headers = {};
-        let body;
-        return {
-            status: (code) => {
-                statusCode = code;
-                return this.createAWSLambdaResponse(lambdaCallback);
-            },
-            json: (data) => {
-                body = JSON.stringify(data);
-                headers['Content-Type'] = 'application/json';
-                lambdaCallback(null, { statusCode, headers, body });
-            },
-            send: (data) => {
-                body = data;
-                lambdaCallback(null, { statusCode, headers, body });
-            },
-            header: (name, value) => {
-                headers[name] = value;
-                return this.createAWSLambdaResponse(lambdaCallback);
-            },
-            headers: (newHeaders) => {
-                Object.assign(headers, newHeaders);
-                return this.createAWSLambdaResponse(lambdaCallback);
-            },
-            end: () => lambdaCallback(null, { statusCode, headers, body }),
-            statusCode,
-            headersSent: false,
-        };
-    }
-    /**
-     * Create response adapter for standard HTTP frameworks (GCP, Express, Fastify)
-     */
-    createStandardHTTPResponse(nativeRes) {
-        const res = nativeRes;
-        return {
-            status: (code) => {
-                res.status(code);
-                return this.createStandardHTTPResponse(nativeRes);
-            },
-            json: (data) => res.json(data),
-            send: (data) => res.send(data),
-            header: (name, value) => {
-                res.header(name, value);
-                return this.createStandardHTTPResponse(nativeRes);
-            },
-            headers: (headers) => {
-                if (res.set) {
-                    res.set(headers); // Express style
-                }
-                else {
-                    Object.entries(headers).forEach(([k, v]) => res.header(k, v)); // GCP style
-                }
-                return this.createStandardHTTPResponse(nativeRes);
-            },
-            end: () => res.end(),
-            get statusCode() {
-                return res.statusCode;
-            },
-            get headersSent() {
-                return res.headersSent;
-            },
-        };
-    }
-    /**
-     * @deprecated Use execute() instead - automatically detects framework
+     * Framework-agnostic execute method that works with GenericRequest/GenericResponse
      */
     async executeGeneric(req, res) {
-        return this.execute(req, res);
+        // Performance optimization: Use container pool instead of creating new containers
+        const container = containerPool_1.containerPool.acquire();
+        const context = (0, core_1.createContext)(req, res, {
+            container,
+        });
+        try {
+            // Execute before middlewares with performance optimizations
+            await this.executeBeforeMiddlewares(context);
+            await this.handler(context);
+            // Execute after middlewares in reverse order using pre-computed array
+            await this.executeAfterMiddlewares(context);
+        }
+        catch (error) {
+            context.error = error;
+            // Execute error handlers using pre-computed array
+            await this.executeErrorMiddlewares(error, context);
+        }
+        finally {
+            // Always return container to pool for reuse
+            containerPool_1.containerPool.release(container);
+        }
     }
 }
 exports.Handler = Handler;

package/build/core/index.d.ts

@@ -2,6 +2,7 @@ export * from './core';
 export * from './errors';
 export * from './handler';
 export * from './logger';
+export * from './containerPool';
 export * from './performanceMonitor';
 export * from '../middlewares';
 //# sourceMappingURL=index.d.ts.map

package/build/core/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./core"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./handler"), exports);
 __exportStar(require("./logger"), exports);
+__exportStar(require("./containerPool"), exports);
 __exportStar(require("./performanceMonitor"), exports);
 __exportStar(require("../middlewares"), exports);
 //# sourceMappingURL=index.js.map

package/build/index.d.ts

@@ -1,3 +1,4 @@
 export * from './core';
 export * from './middlewares';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -14,6 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// Core exports
 __exportStar(require("./core"), exports);
+// Middleware exports
 __exportStar(require("./middlewares"), exports);
+// Utility exports
+__exportStar(require("./utils"), exports);
 //# sourceMappingURL=index.js.map

package/build/middlewares/ProcessingMiddleware.js

@@ -312,7 +312,9 @@ class ProcessingMiddleware {
     }
     extractContentLength(req) {
         const contentLength = req.headers?.['content-length'] || req.headers?.['Content-Length'];
-        const lengthValue = Array.isArray(contentLength) ? contentLength[0] : contentLength;
+        const lengthValue = Array.isArray(contentLength)
+            ? contentLength[0]
+            : contentLength;
         return lengthValue ? parseInt(lengthValue, 10) : undefined;
     }
     extractAcceptLanguage(req) {

package/build/middlewares/bodyValidationMiddleware.d.ts

@@ -23,21 +23,20 @@ import { z } from 'zod';
  *
  * type UserRequest = z.infer<typeof userSchema>;
  *
- * async function handleCreateUser(context: Context<UserRequest>) {
+ * async function handleCreateUser(context: Context<UserRequest, AuthenticatedUser>) {
  *   const user = context.req.validatedBody!; // Fully typed
- *   const authenticatedUser = context.user; // User type inferred from auth middleware
  *   return { success: true, user: { id: '123', ...user } };
  * }
  *
- * const createUserHandler = new Handler<UserRequest>()
- *   .use(new BodyValidationMiddleware<UserRequest>(userSchema))
+ * const createUserHandler = new Handler<UserRequest, AuthenticatedUser>()
+ *   .use(new BodyValidationMiddleware<UserRequest, AuthenticatedUser>(userSchema))
  *   .handle(handleCreateUser);
  * ```
  */
-export declare class BodyValidationMiddleware<T = unknown> implements BaseMiddleware<T> {
+export declare class BodyValidationMiddleware<T = unknown, U = unknown> implements BaseMiddleware<T, U> {
     private readonly schema;
     constructor(schema: z.ZodSchema<T>);
-    before(context: Context<T>): Promise<void>;
+    before(context: Context<T, U>): Promise<void>;
 }
 /**
  * Factory function that creates a body validation middleware with Zod schema validation.
@@ -60,19 +59,18 @@ export declare class BodyValidationMiddleware<T = unknown> implements BaseMiddle
  *
  * type LoginRequest = z.infer<typeof loginSchema>;
  *
- * async function handleLogin(context: Context<LoginRequest>) {
+ * async function handleLogin(context: Context<LoginRequest, AuthenticatedUser>) {
  *   const credentials = context.req.parsedBody as LoginRequest;
  *   const token = await authenticate(credentials.username, credentials.password);
- *   const authenticatedUser = context.user; // User type from auth middleware
  *   return { success: true, token };
  * }
  *
- * const loginHandler = new Handler<LoginRequest>()
- *   .use(bodyValidatorMiddleware<LoginRequest>(loginSchema))
+ * const loginHandler = new Handler<LoginRequest, AuthenticatedUser>()
+ *   .use(bodyValidatorMiddleware<LoginRequest, AuthenticatedUser>(loginSchema))
  *   .handle(handleLogin);
  * ```
  */
-export declare const bodyValidatorMiddleware: <T>(schema: z.ZodType<T>) => {
-    before: (context: Context<T>) => Promise<void>;
+export declare const bodyValidatorMiddleware: <T, U = unknown>(schema: z.ZodType<T>) => {
+    before: (context: Context<T, U>) => Promise<void>;
 };
 //# sourceMappingURL=bodyValidationMiddleware.d.ts.map

package/build/middlewares/bodyValidationMiddleware.js

@@ -36,14 +36,13 @@ const validateBody = async (schema, data) => {
  *
  * type UserRequest = z.infer<typeof userSchema>;
  *
- * async function handleCreateUser(context: Context<UserRequest>) {
+ * async function handleCreateUser(context: Context<UserRequest, AuthenticatedUser>) {
  *   const user = context.req.validatedBody!; // Fully typed
- *   const authenticatedUser = context.user; // User type inferred from auth middleware
  *   return { success: true, user: { id: '123', ...user } };
  * }
  *
- * const createUserHandler = new Handler<UserRequest>()
- *   .use(new BodyValidationMiddleware<UserRequest>(userSchema))
+ * const createUserHandler = new Handler<UserRequest, AuthenticatedUser>()
+ *   .use(new BodyValidationMiddleware<UserRequest, AuthenticatedUser>(userSchema))
  *   .handle(handleCreateUser);
  * ```
  */
@@ -78,19 +77,18 @@ exports.BodyValidationMiddleware = BodyValidationMiddleware;
  *
  * type LoginRequest = z.infer<typeof loginSchema>;
  *
- * async function handleLogin(context: Context<LoginRequest>) {
+ * async function handleLogin(context: Context<LoginRequest, AuthenticatedUser>) {
  *   const credentials = context.req.parsedBody as LoginRequest;
  *   const token = await authenticate(credentials.username, credentials.password);
- *   const authenticatedUser = context.user; // User type from auth middleware
  *   return { success: true, token };
  * }
  *
- * const loginHandler = new Handler<LoginRequest>()
- *   .use(bodyValidatorMiddleware<LoginRequest>(loginSchema))
+ * const loginHandler = new Handler<LoginRequest, AuthenticatedUser>()
+ *   .use(bodyValidatorMiddleware<LoginRequest, AuthenticatedUser>(loginSchema))
  *   .handle(handleLogin);
  * ```
  */
-// Simplified factory function for body validation middleware
+// Modified to fix type instantiation error
 const bodyValidatorMiddleware = (schema) => ({
     before: async (context) => {
         context.req.parsedBody = await validateBody(schema, context.req.body);

package/build/middlewares/guards/RouteGuards.d.ts

@@ -42,8 +42,8 @@
  *       return { valid: false, error: error.message };
  *     }
  *   },
- *   extractUserId: (decoded: unknown) => (decoded as any).sub,
- *   isTokenExpired: (decoded: unknown) => (decoded as any).exp < Date.now() / 1000
+ *   extractUserId: (decoded: any) => decoded.sub,
+ *   isTokenExpired: (decoded: any) => decoded.exp < Date.now() / 1000
  * };
  *
  * // Configure guard system

package/build/middlewares/guards/RouteGuards.js

@@ -43,8 +43,8 @@
  *       return { valid: false, error: error.message };
  *     }
  *   },
- *   extractUserId: (decoded: unknown) => (decoded as any).sub,
- *   isTokenExpired: (decoded: unknown) => (decoded as any).exp < Date.now() / 1000
+ *   extractUserId: (decoded: any) => decoded.sub,
+ *   isTokenExpired: (decoded: any) => decoded.exp < Date.now() / 1000
  * };
  *
  * // Configure guard system

package/build/middlewares/guards/adapters/CustomTokenVerificationPortAdapter.d.ts

@@ -245,7 +245,7 @@ export declare class TokenVerificationAdapterFactory {
      * @param expirationField - Optional field name for expiration (e.g., 'expiresAt', 'exp')
      * @returns Configured adapter for API key tokens
      */
-    static forAPIKey<T extends Record<string, unknown>>(verificationPort: CustomTokenVerificationPort<T>, userIdField: keyof T, expirationField?: keyof T): CustomTokenVerificationPortAdapter<T>;
+    static forAPIKey<T extends Record<string, any>>(verificationPort: CustomTokenVerificationPort<T>, userIdField: keyof T, expirationField?: keyof T): CustomTokenVerificationPortAdapter<T>;
     /**
      * Create adapter for OAuth tokens with standard OAuth claims.
      *

package/build/middlewares/guards/guards/FastAuthGuard.d.ts

@@ -43,7 +43,7 @@ export interface AuthenticationResult {
     success: boolean;
     user?: UserContext;
     token?: {
-        decoded: unknown;
+        decoded: any;
         raw: string;
         expiresAt: string;
         issuer?: string;
@@ -63,7 +63,7 @@ export interface AuthGuardConfig {
     allowedIssuers?: string[];
     requireEmailVerification: boolean;
     allowInactiveUsers: boolean;
-    customValidation?: (token: unknown, user: UserContext) => Promise<boolean>;
+    customValidation?: (token: any, user: UserContext) => Promise<boolean>;
 }
 /**
  * Token validation service interface
@@ -74,17 +74,17 @@ export interface TokenValidator {
      */
     validateToken(token: string): Promise<{
         valid: boolean;
-        decoded?: unknown;
+        decoded?: any;
         error?: string;
     }>;
     /**
      * Extract user ID from decoded token
      */
-    extractUserId(decoded: unknown): string;
+    extractUserId(decoded: any): string;
     /**
      * Check if token is expired
      */
-    isTokenExpired(decoded: unknown): boolean;
+    isTokenExpired(decoded: any): boolean;
 }
 /**
  * Fast Authentication Guard Implementation

package/build/middlewares/guards/guards/PermissionGuardFactory.d.ts

@@ -162,8 +162,16 @@ export declare class PermissionGuardFactory {
     getStats(): {
         totalGuards: number;
         guardsByType: Record<string, number>;
-        individualGuardStats: Record<string, unknown>[];
-        aggregatedStats: Record<string, unknown>;
+        individualGuardStats: {
+            guardType: string;
+            checkCount: number;
+            successCount: number;
+            failureCount: number;
+            successRate: number;
+            averageProcessingTimeUs: number;
+            totalProcessingTimeUs: number;
+        }[];
+        aggregatedStats: any;
     };
     /**
      * Clear guard cache

package/build/middlewares/guards/guards/PermissionGuardFactory.js

@@ -388,7 +388,7 @@ let PermissionGuardFactory = class PermissionGuardFactory {
     createCompositeGuard(requirements, config = {}) {
         const fullConfig = {
             requireAuth: true,
-            permissions: requirements, // Store requirements as permissions for cache key
+            permissions: requirements, // Store requirements as permissions for cache key (complex composite type)
             cacheResults: true,
             auditTrail: false,
             ...config,
@@ -421,7 +421,9 @@ let PermissionGuardFactory = class PermissionGuardFactory {
                 return this.createExpressionGuard(permissions, config);
             default:
                 // Fallback to plain guard
-                return this.createPlainGuard(Array.isArray(permissions) ? permissions : [permissions], config);
+                return this.createPlainGuard(Array.isArray(permissions)
+                    ? permissions
+                    : [permissions], config);
         }
     }
     /**
@@ -534,7 +536,8 @@ let PermissionGuardFactory = class PermissionGuardFactory {
             checkCount: acc.checkCount + (stats.checkCount || 0),
             successCount: acc.successCount + (stats.successCount || 0),
             failureCount: acc.failureCount + (stats.failureCount || 0),
-            totalProcessingTimeUs: acc.totalProcessingTimeUs + (stats.totalProcessingTimeUs || 0),
+            totalProcessingTimeUs: acc.totalProcessingTimeUs +
+                (stats.totalProcessingTimeUs || 0),
         }), {
             checkCount: 0,
             successCount: 0,
@@ -546,10 +549,12 @@ let PermissionGuardFactory = class PermissionGuardFactory {
             totalSuccesses: totals.successCount,
             totalFailures: totals.failureCount,
             overallSuccessRate: totals.checkCount > 0
-                ? (totals.successCount / totals.checkCount) * 100
+                ? (totals.successCount / totals.checkCount) *
+                    100
                 : 100,
             averageProcessingTimeUs: totals.checkCount > 0
-                ? totals.totalProcessingTimeUs / totals.checkCount
+                ? totals.totalProcessingTimeUs /
+                    totals.checkCount
                 : 0,
         };
     }

package/build/middlewares/guards/resolvers/ExpressionPermissionResolver.d.ts

@@ -118,7 +118,7 @@ export declare class ExpressionPermissionResolver extends PermissionResolver<Per
     /**
      * Check if this resolver can handle the given requirement type
      */
-    canHandle(requirement: unknown): requirement is PermissionExpression;
+    canHandle(requirement: any): requirement is PermissionExpression;
     /**
      * Normalize expression for consistent cache keys
      *

package/build/middlewares/guards/resolvers/ExpressionPermissionResolver.js

@@ -412,7 +412,7 @@ class ExpressionPermissionResolver extends PermissionResolver_1.PermissionResolv
      * Check if this resolver can handle the given requirement type
      */
     canHandle(requirement) {
-        return Boolean(requirement &&
+        return (requirement &&
             typeof requirement === 'object' &&
             PermissionResolver_1.PermissionUtils.isValidExpression(requirement));
     }

package/build/middlewares/guards/resolvers/PermissionResolver.d.ts

@@ -19,7 +19,7 @@
  * different types of permission requirements. The generic type T represents
  * the specific requirement format for each resolver.
  */
-export declare abstract class PermissionResolver<T = unknown> {
+export declare abstract class PermissionResolver<T = any> {
     /**
      * Check if user permissions satisfy the requirement
      *

package/build/middlewares/guards/resolvers/PlainPermissionResolver.d.ts

@@ -96,6 +96,6 @@ export declare class PlainPermissionResolver extends PermissionResolver<string[]
      * @param requirement - The requirement to check
      * @returns true if this resolver can handle the requirement
      */
-    canHandle(requirement: unknown): requirement is string[];
+    canHandle(requirement: any): requirement is string[];
 }
 //# sourceMappingURL=PlainPermissionResolver.d.ts.map

package/build/middlewares/guards/resolvers/WildcardPermissionResolver.d.ts

@@ -141,6 +141,6 @@ export declare class WildcardPermissionResolver extends PermissionResolver<strin
     /**
      * Check if this resolver can handle the given requirement type
      */
-    canHandle(requirement: unknown): requirement is string[];
+    canHandle(requirement: any): requirement is string[];
 }
 //# sourceMappingURL=WildcardPermissionResolver.d.ts.map

package/build/middlewares/guards/services/FastUserContextService.d.ts

@@ -23,13 +23,14 @@
  * @version 1.0.0
  */
 import { CacheAdapter } from '../cache/CacheAdapter';
-import { GuardConfiguration } from '../config/GuardConfiguration';
+import { GuardConfiguration, PermissionResolutionStrategy } from '../config/GuardConfiguration';
 import { PermissionRegistry } from '../registry/PermissionRegistry';
 import { PermissionResolverType, PermissionCheckResult, PermissionExpression } from '../resolvers/PermissionResolver';
 /**
  * Type alias for permission requirements that can be strings, string arrays, or complex expressions
+ * Note: Currently defined but reserved for future use
  */
-type PermissionRequirement = string | string[] | PermissionExpression | Record<string, unknown>;
+export type PermissionRequirement = string | string[] | PermissionExpression | Record<string, unknown>;
 /**
  * User context with cached permissions and metadata
  */
@@ -37,7 +38,7 @@ export interface UserContext {
     userId: string;
     permissions: Set<string>;
     roles: string[];
-    metadata: Record<string, unknown>;
+    metadata: Record<string, any>;
     expandedPermissions?: Set<string>;
     lastUpdated: string;
     expiresAt?: string;
@@ -52,7 +53,7 @@ export interface UserPermissionSource {
     getUserPermissions(userId: string): Promise<{
         permissions: string[];
         roles: string[];
-        metadata?: Record<string, unknown>;
+        metadata?: Record<string, any>;
     } | null>;
     /**
      * Get role-based permissions for expansion
@@ -117,7 +118,7 @@ export declare class FastUserContextService {
      * @param options - Check options
      * @returns Detailed permission check result
      */
-    checkPermission(userId: string, requirement: PermissionRequirement, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
+    checkPermission(userId: string, requirement: any, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
     /**
      * Batch check multiple permissions for a user
      *
@@ -130,7 +131,7 @@ export declare class FastUserContextService {
      * @returns Array of permission check results
      */
     checkPermissions(userId: string, requirements: Array<{
-        requirement: PermissionRequirement;
+        requirement: any;
         resolverType?: PermissionResolverType;
     }>, options?: PermissionCheckOptions): Promise<PermissionCheckResult[]>;
     /**
@@ -165,9 +166,33 @@ export declare class FastUserContextService {
         averageResolutionTimeUs: number;
         totalResolutionTimeUs: number;
         resolverStats: {
-            plain: Record<string, unknown>;
-            wildcard: Record<string, unknown>;
-            expression: Record<string, unknown>;
+            plain: {
+                checkCount: number;
+                averageResolutionTimeUs: number;
+                totalResolutionTimeUs: number;
+            };
+            wildcard: {
+                strategy: PermissionResolutionStrategy;
+                checkCount: number;
+                averageResolutionTimeUs: number;
+                totalResolutionTimeUs: number;
+                cacheHitRate: number;
+                cacheHits: number;
+                cacheMisses: number;
+            };
+            expression: {
+                checkCount: number;
+                averageResolutionTimeUs: number;
+                totalResolutionTimeUs: number;
+                cacheHitRate: number;
+                cacheHits: number;
+                cacheMisses: number;
+                complexityDistribution: {
+                    simple: number;
+                    moderate: number;
+                    complex: number;
+                };
+            };
         };
     };
     /**
@@ -199,5 +224,4 @@ export declare class FastUserContextService {
      */
     private recordAuditTrail;
 }
-export {};
 //# sourceMappingURL=FastUserContextService.d.ts.map