/**
 * Lambda context information for logging and monitoring.
 */
export interface LambdaContextInfo {
    /** Lambda function name */
    functionName?: string;
    /** Lambda function version */
    functionVersion?: string;
    /** AWS request ID */
    awsRequestId?: string;
    /** Remaining time in milliseconds */
    getRemainingTimeInMillis?: () => number;
    /** Memory limit in MB */
    memoryLimitInMB?: string;
    /** Log group name */
    logGroupName?: string;
    /** Log stream name */
    logStreamName?: string;
}
/**
 * Handler metadata for logging context.
 */
export interface HandlerMetadata {
    /** Lambda identifier (e.g., 'payments.charge') */
    id: string;
    /** Service name (e.g., 'payments') */
    service: string;
}
/**
 * Execution metrics collected during handler invocation.
 */
export interface ExecutionMetrics {
    /** Start timestamp */
    startTime: number;
    /** End timestamp */
    endTime: number;
    /** Duration in milliseconds */
    duration: number;
    /** Memory usage information (if available) */
    memoryUsed?: number;
    /** Remaining time when handler completed */
    remainingTime?: number;
}
/**
 * Logging wrapper for Lambda invocation lifecycle.
 *
 * Provides structured logging for Lambda invocation start/end with
 * contextual information including timing, memory usage, and AWS
 * Lambda context details.
 *
 * @param handler - Original Lambda handler function
 * @param metadata - Handler metadata for logging context
 * @returns Wrapped handler with logging
 *
 * @example
 * ```typescript
 * const wrappedHandler = loggingWrapper(
 *   async (event, context) => { return { success: true }; },
 *   { id: 'payments.charge', service: 'payments' }
 * );
 * ```
 */
export declare function loggingWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
/**
 * Error wrapper for Lambda handler error handling.
 *
 * Catches and logs errors with structured information, then returns
 * appropriate error responses. Handles both thrown errors and rejected
 * promises consistently.
 *
 * @param handler - Original Lambda handler function
 * @param metadata - Handler metadata for error context
 * @returns Wrapped handler with error handling
 *
 * @example
 * ```typescript
 * const wrappedHandler = errorWrapper(
 *   async (event, context) => { return { success: true }; },
 *   { id: 'payments.charge', service: 'payments' }
 * );
 * ```
 */
export declare function errorWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
/**
 * Timing wrapper for Lambda handler performance monitoring.
 *
 * Measures handler execution time and memory usage, providing
 * detailed performance metrics for monitoring and optimization.
 *
 * @param handler - Original Lambda handler function
 * @param metadata - Handler metadata for timing context
 * @returns Wrapped handler with timing measurements
 *
 * @example
 * ```typescript
 * const wrappedHandler = timingWrapper(
 *   async (event, context) => { return { success: true }; },
 *   { id: 'payments.charge', service: 'payments' }
 * );
 * ```
 */
export declare function timingWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
/**
 * Combined wrapper that applies logging, error handling, and timing.
 *
 * Convenience function that applies all three wrappers in the correct
 * order: timing (innermost) → error handling → logging (outermost).
 *
 * @param handler - Original Lambda handler function
 * @param metadata - Handler metadata for all wrappers
 * @returns Fully wrapped handler with all enhancements
 *
 * @example
 * ```typescript
 * const wrappedHandler = fullWrapper(
 *   async (event, context) => { return { success: true }; },
 *   { id: 'payments.charge', service: 'payments' }
 * );
 * ```
 */
export declare function fullWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
