import { PlatformHeader } from './PlatformHeader';
/**
 * ContextReader - Interface for reading header values from context.
 *
 * Different implementations for different environments:
 * - RequestContextReader: Node.js with AsyncLocalStorage (in @webpieces/http-routing, server-side only)
 * - StaticContextReader: Browser or testing with manual header management (in @webpieces/http-client)
 * - CompositeContextReader: Combines multiple readers with priority (in @webpieces/http-client)
 *
 * This interface is defined in @webpieces/http-api so both http-routing and http-client
 * can use it without creating circular dependencies.
 *
 * This interface is DI-independent so it works in both server (Inversify)
 * and client (Angular, browser) environments.
 */
export interface ContextReader {
    /**
     * Read the value of a platform header.
     * Returns undefined if header not available.
     *
     * @param header - The platform header to read
     * @returns The header value, or undefined if not present
     */
    read(header: PlatformHeader): string | undefined;
}
/**
 * HeaderMethods - Utility class for working with platform headers.
 *
 * This class can be injected in both server (Node.js) and client (Angular/browser) environments.
 * It provides common operations for filtering and processing headers.
 *
 * Pattern: Stateless utility class (pure functions, can be instantiated or injected)
 * - Server: Can inject empty instance, use static-like methods
 * - Client: new HeaderMethods() (no DI needed)
 *
 * Usage:
 * ```typescript
 * // Server-side (ContextFilter)
 * constructor(@inject() headerMethods: HeaderMethods) {
 *     const allHeaders = [... flatten from extensions ...];
 *     this.transferHeaders = headerMethods.findTransferHeaders(allHeaders);
 * }
 *
 * // Client-side (ClientFactory)
 * const headerMethods = new HeaderMethods();
 * const loggableHeaders = headerMethods.findLoggableHeaders(allHeaders, requestHeaders);
 * ```
 */
export declare class HeaderMethods {
    /**
     * Filter headers to only those that should be transferred (isWantTransferred=true).
     *
     * @param headers - Array of PlatformHeader definitions
     * @returns Filtered array of headers with isWantTransferred=true
     */
    findTransferHeaders(headers: PlatformHeader[]): PlatformHeader[];
    /**
     * Split headers into secure and public categories.
     *
     * @param headers - Array of PlatformHeader definitions
     * @returns SplitHeaders with secureHeaders (isSecured=true) and publicHeaders (isSecured=false)
     */
    secureHeaders(headers: PlatformHeader[]): PlatformHeader[];
    /**
     * Get all headers that should be logged.
     * All headers are loggable - secure headers will be masked by formatHeadersForLogging.
     *
     * @param headers - Array of PlatformHeader definitions
     * @returns All headers (they're all loggable, just some are masked)
     */
    findLoggableHeaders(headers: PlatformHeader[]): PlatformHeader[];
    buildSecureMapForLogs(platformHeaders: PlatformHeader[], contextReader: ContextReader): Map<string, any>;
    /**
     * Format headers for logging with secure masking.
     * Takes filtered PlatformHeaders and actual header values from request.
     *
     * Masking rules for secure headers (isSecured=true):
     * - Length > 15: Show first 3 and last 3 characters with "..." between
     * - Length 8-15: Show first 2 characters with "..."
     * - Length < 8: Show "<secure key too short to log>"
     *
     * @param loggableHeaders - Filtered PlatformHeaders to log
     * @param headerMap - Map of header name (lowercase) -> array of values from request
     * @returns Record of header name -> masked or full value for logging
     */
    formatHeadersForLogging(loggableHeaders: PlatformHeader[], headerMap: Map<string, string[]>): Record<string, string>;
    /**
     * Mask a secure header value based on its length.
     *
     * @param value - The secure header value to mask
     * @returns Masked value
     */
    private maskSecureValue;
}