@allan1361/iota-big3-sdk-middleware/dist/types/performance.d.ts

🏆 A+ Grade Certified Enterprise Middleware Framework - Phase 3 Certified (90/100) with advanced resilience patterns, comprehensive type safety, and production-ready observability

import type { Request } from 'express';
import type { JsonObject, MiddlewareFunction } from './types';
export interface PerformanceMetrics {
    executionTime: number;
    memoryUsage: {
        heapUsed: number;
        heapTotal: number;
        external: number;
        rss: number;
    };
    requestSize: number;
    responseSize: number;
    timestamp: number;
}
export interface PerformanceConfig {
    enableProfiling: boolean;
    enableMemoryTracking: boolean;
    enableRequestSizeTracking: boolean;
    sampleRate: number;
    slowRequestThreshold: number;
    memoryLeakThreshold: number;
}
export declare class PerformanceMonitor {
    private config;
    private metrics;
    private slowRequests;
    private memoryBaseline;
    constructor(config: PerformanceConfig);
    createProfilingMiddleware(): MiddlewareFunction;
    private calculateRequestSize;
    private recordMetrics;
    private onMemoryLeakDetected;
    getPerformanceReport(): JsonObject;
    private calculateAverage;
    private calculatePercentile;
    clearMetrics(): void;
}
export declare class RequestBatcher<T> {
    private batchProcessor;
    private options;
    private queue;
    private batchTimer?;
    constructor(batchProcessor: (items: T[]) => Promise<unknown[]>, options: {
        maxBatchSize: number;
        maxWaitTime: number;
    });
    add(item: T): Promise<unknown>;
    private processBatch;
}
export declare class ObjectPool<T> {
    private pool;
    private createFn;
    private resetFn;
    constructor(createFn: () => T, resetFn: (obj: T) => void, initialSize?: number);
    acquire(): T;
    release(obj: T): void;
    size(): number;
}
export declare class ResponseCache {
    private defaultTtlMs;
    private cache;
    private cleanupInterval?;
    constructor(defaultTtlMs?: number);
    set(key: string, data: unknown, ttlMs?: number): void;
    get(key: string): unknown | undefined;
    delete(key: string): boolean;
    clear(): void;
    size(): number;
    private startCleanup;
    shutdown(): void;
}
export declare class OptimizedMiddlewareFactory {
    private performanceMonitor;
    private responseCache;
    private requestBatcher;
    constructor(performanceConfig: PerformanceConfig, cacheConfig?: {
        defaultTtlMs: number;
    });
    createPerformanceMiddleware(): MiddlewareFunction;
    createCacheMiddleware(options: {
        keyGenerator: (req: Request) => string;
        ttlMs?: number;
        cacheableStatusCodes?: number[];
    }): MiddlewareFunction;
    createBatchingMiddleware(): MiddlewareFunction;
    getPerformanceReport(): JsonObject;
    shutdown(): void;
}
export declare function createOptimizedMiddleware(performanceConfig?: Partial<PerformanceConfig>, cacheConfig?: {
    defaultTtlMs: number;
}): OptimizedMiddlewareFactory;
//# sourceMappingURL=performance.d.ts.map