import type { AuthUser as BaseAuthUser, JsonObject, JsonValue } from '@iota-big3/sdk-types';
import type { NextFunction, Request, Response } from 'express';
import type { FastifyReply, FastifyRequest } from 'fastify';
export type AuthUser = BaseAuthUser;
export type Result<T, E = Error> = {
    success: true;
    data: T;
} | {
    success: false;
    error: E;
};
export declare function isJsonValue(value: unknown): value is JsonValue;
export declare function isJsonObject(value: unknown): value is JsonObject;
export declare function isAuthUser(value: unknown): value is AuthUser;
export declare function isAuthResult(value: unknown): value is AuthResult;
export declare function isValidationResult(value: unknown): value is ValidationResult;
export declare function isValidHeaderValue(value: unknown): value is string | string[];
export declare function isMiddlewareConfig(value: unknown): value is MiddlewareConfig;
export declare function extractHeaderString(value: unknown): string | undefined;
export declare function extractQueryString(value: unknown): string | undefined;
export declare function validateJsonBody(body: unknown): Result<JsonValue, string>;
export type { AnyFunction, JsonObject, JsonValue } from '@iota-big3/sdk-types';
export interface AuthResult {
    valid: boolean;
    user?: AuthUser;
    error?: string;
}
export interface ValidationResult {
    valid: boolean;
    errors?: Array<{
        field: string;
        message: string;
    }>;
}
export interface Logger {
    info(message: string, meta?: JsonObject): void;
    error(message: string, meta?: JsonObject): void;
    warn(message: string, meta?: JsonObject): void;
    debug(message: string, meta?: JsonObject): void;
}
export interface HttpClient {
    get<T = JsonValue>(url: string, options?: JsonObject): Promise<T>;
    post<T = JsonValue>(url: string, data?: JsonValue, options?: JsonObject): Promise<T>;
    put<T = JsonValue>(url: string, data?: JsonValue, options?: JsonObject): Promise<T>;
    delete<T = JsonValue>(url: string, options?: JsonObject): Promise<T>;
}
export type MiddlewareFunction = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
export type ErrorMiddlewareFunction = (error: Error, req: Request, res: Response, next: NextFunction) => void | Promise<void>;
export type FastifyMiddlewareFunction = (request: FastifyRequest, reply: FastifyReply) => void | Promise<void>;
export interface AuthenticatedRequest extends Request {
    user?: AuthUser;
    auth?: {
        token: string;
        decoded: JsonValue;
    };
}
export interface FastifyAuthenticatedRequest extends FastifyRequest {
    user?: AuthUser;
    auth?: {
        token: string;
        decoded: JsonValue;
    };
}
export interface MiddlewareConfig {
    name: string;
    enabled?: boolean;
    priority?: number;
    options?: Record<string, JsonValue>;
    metadata?: Record<string, JsonValue>;
}
export interface SDKIntegrations {
    auth?: {
        validateToken(token: string): Promise<AuthResult>;
    };
    security?: {
        validate(data: JsonValue, schema: JsonValue): Promise<ValidationResult>;
        sanitizeInput(data: JsonValue): JsonValue;
    };
    observability?: {
        createLogger(name: string): Logger;
    };
    integration?: {
        createHttpClient(options?: JsonObject): HttpClient;
    };
}
export interface MiddlewareHealth {
    status: 'healthy' | 'degraded' | 'unhealthy';
    middleware: Array<{
        name: string;
        status: 'active' | 'inactive' | 'error';
        executionCount: number;
        errorCount: number;
        averageExecutionTime: number;
    }>;
    timestamp: Date;
}
export interface MiddlewareEvents {
    'middleware:registered': {
        name: string;
        config: MiddlewareConfig;
    };
    'middleware:unregistered': {
        name: string;
    };
    'middleware:executed': {
        name: string;
        duration: number;
    };
    'middleware:error': {
        name: string;
        error: Error;
    };
    'request:start': {
        requestId: string;
        method: string;
        path: string;
    };
    'request:complete': {
        requestId: string;
        statusCode: number;
        duration: number;
    };
}
export interface MiddlewareRegistration {
    name: string;
    middleware: MiddlewareFunction | ErrorMiddlewareFunction;
    options: MiddlewareConfig;
    type: 'normal' | 'error';
    metrics: {
        executionCount: number;
        errorCount: number;
        totalDuration: number;
    };
}
export interface IMiddlewareManager {
    register(name: string, middleware: MiddlewareFunction | ErrorMiddlewareFunction, config?: MiddlewareConfig): void;
    unregister(name: string): boolean;
    execute(req: Request, res: Response, finalCallback?: NextFunction): Promise<void>;
    createAuthMiddleware(options?: AuthMiddlewareOptions): MiddlewareFunction;
    createValidationMiddleware(schema: JsonValue, options?: ValidationMiddlewareOptions): MiddlewareFunction;
    createLoggingMiddleware(options?: LoggingMiddlewareOptions): MiddlewareFunction;
    createRateLimitMiddleware(options?: RateLimitMiddlewareOptions): MiddlewareFunction;
    createCorsMiddleware(options?: CorsMiddlewareOptions): MiddlewareFunction;
    createCompressionMiddleware(options?: CompressionMiddlewareOptions): MiddlewareFunction;
    getHealth(): MiddlewareHealth;
    on(event: keyof MiddlewareEvents, handler: (data: MiddlewareEvents[keyof MiddlewareEvents]) => void): void;
    off(event: keyof MiddlewareEvents, handler: (data: MiddlewareEvents[keyof MiddlewareEvents]) => void): void;
}
export interface AuthMiddlewareOptions {
    publicPaths?: string[];
    requireAuth?: boolean;
    getUserFromToken?: (token: JsonValue) => Promise<AuthUser | null>;
    tokenLocation?: 'header' | 'cookie' | 'query';
    tokenKey?: string;
    optional?: boolean;
    roles?: string[];
    permissions?: string[];
}
export interface ValidationMiddlewareOptions {
    location?: 'body' | 'query' | 'params';
    stripUnknown?: boolean;
    abortEarly?: boolean;
}
export interface LoggingMiddlewareOptions {
    level?: 'info' | 'debug' | 'warn' | 'error';
    includeBody?: boolean;
    includeHeaders?: boolean;
    excludePaths?: string[];
}
export interface RateLimitMiddlewareOptions {
    windowMs?: number;
    max?: number;
    message?: string;
    keyGenerator?: (req: Request) => string;
    skipSuccessfulRequests?: boolean;
    skipFailedRequests?: boolean;
}
export interface CorsMiddlewareOptions {
    origin?: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void);
    methods?: string[];
    allowedHeaders?: string[];
    exposedHeaders?: string[];
    credentials?: boolean;
    maxAge?: number;
    preflightContinue?: boolean;
    optionsSuccessStatus?: number;
}
export interface CompressionMiddlewareOptions {
    level?: number;
    threshold?: number | string;
    filter?: (req: Request, res: Response) => boolean;
}
//# sourceMappingURL=types.d.ts.map