/**
 * Span Processor
 * Handles span processing before export - enrichment, filtering, and transformation
 * Fills the 9% gap in pattern compliance
 */
import type { SpanAttributes, SpanData } from "./types/index.js";
import type { SpanProcessor } from "../types/observability.js";
export type { SpanProcessor };
/**
 * No-op processor that passes spans through unchanged
 */
export declare class PassThroughProcessor implements SpanProcessor {
    readonly name = "pass-through";
    process(span: SpanData): SpanData;
}
/**
 * Attribute enrichment processor
 * Adds additional attributes to spans based on configuration
 */
export declare class AttributeEnrichmentProcessor implements SpanProcessor {
    readonly name = "attribute-enrichment";
    private readonly staticAttributes;
    private readonly dynamicAttributes;
    constructor(config: {
        staticAttributes?: SpanAttributes;
        dynamicAttributes?: (span: SpanData) => Partial<SpanAttributes>;
    });
    process(span: SpanData): SpanData;
}
/**
 * Filter processor - drops spans based on conditions
 */
export declare class FilterProcessor implements SpanProcessor {
    readonly name = "filter";
    private readonly predicate;
    constructor(predicate: (span: SpanData) => boolean);
    process(span: SpanData): SpanData | null;
}
/**
 * Redaction processor - removes sensitive data from spans
 */
export declare class RedactionProcessor implements SpanProcessor {
    readonly name = "redaction";
    private readonly sensitiveKeys;
    private readonly redactedValue;
    constructor(config?: {
        sensitiveKeys?: string[];
        redactedValue?: string;
    });
    process(span: SpanData): SpanData;
    private redactObject;
}
/**
 * Truncation processor - truncates large attribute values
 */
export declare class TruncationProcessor implements SpanProcessor {
    readonly name = "truncation";
    private readonly maxStringLength;
    private readonly maxArrayLength;
    constructor(config?: {
        maxStringLength?: number;
        maxArrayLength?: number;
    });
    process(span: SpanData): SpanData;
    private truncateAttributes;
    private truncateValue;
}
/**
 * Composite processor - chains multiple processors together
 */
export declare class CompositeProcessor implements SpanProcessor {
    readonly name = "composite";
    private readonly processors;
    constructor(processors: SpanProcessor[]);
    process(span: SpanData): SpanData | null;
    processAsync(span: SpanData): Promise<SpanData | null>;
    shutdown(): Promise<void>;
}
/**
 * Batch processor - collects spans and processes them in batches
 */
export declare class BatchProcessor implements SpanProcessor {
    readonly name = "batch";
    private readonly innerProcessor;
    private readonly batchSize;
    private readonly flushIntervalMs;
    private batch;
    private flushTimer;
    private onBatchReady?;
    constructor(config: {
        processor?: SpanProcessor;
        batchSize?: number;
        flushIntervalMs?: number;
        onBatchReady?: (spans: SpanData[]) => void;
    });
    process(span: SpanData): SpanData | null;
    private startFlushTimer;
    private flush;
    shutdown(): Promise<void>;
}
/**
 * Factory for creating span processors
 */
export declare class SpanProcessorFactory {
    /**
     * Create a standard processor pipeline for production use
     */
    static createProductionPipeline(config?: {
        serviceName?: string;
        environment?: string;
        additionalProcessors?: SpanProcessor[];
    }): CompositeProcessor;
    /**
     * Create a minimal processor pipeline for development
     */
    static createDevelopmentPipeline(): CompositeProcessor;
}
