/**
 * Telemetry Integration - External telemetry system integrations
 *
 * Provides hooks for connecting to external observability systems.
 */
/**
 * Telemetry sink types
 */
export type TelemetrySinkType = 'console' | 'http' | 'custom';
/**
 * Telemetry record
 */
export interface TelemetryRecord {
    id: string;
    type: 'event' | 'metric' | 'trace' | 'log';
    name: string;
    value?: number;
    tags?: Record<string, string>;
    timestamp: number;
    data?: any;
}
/**
 * Telemetry sink interface
 */
export interface TelemetrySink {
    name: string;
    type: TelemetrySinkType;
    send(records: TelemetryRecord[]): Promise<void>;
    flush?(): Promise<void>;
    close?(): Promise<void>;
}
/**
 * Console sink
 */
export declare class ConsoleSink implements TelemetrySink {
    name: string;
    type: TelemetrySinkType;
    private format;
    constructor(format?: 'json' | 'pretty');
    send(records: TelemetryRecord[]): Promise<void>;
}
/**
 * HTTP sink
 */
export declare class HTTPSink implements TelemetrySink {
    name: string;
    type: TelemetrySinkType;
    private endpoint;
    private headers;
    private batchSize;
    private buffer;
    constructor(config: {
        name?: string;
        endpoint: string;
        headers?: Record<string, string>;
        batchSize?: number;
    });
    send(records: TelemetryRecord[]): Promise<void>;
    flush(): Promise<void>;
    private sendBatch;
}
/**
 * Integration hub configuration
 */
export interface TelemetryIntegrationConfig {
    /** Sinks to send records to */
    sinks?: TelemetrySink[];
    /** Buffer size before auto-flush */
    bufferSize?: number;
    /** Flush interval in ms */
    flushInterval?: number;
    /** Enable/disable */
    enabled?: boolean;
}
/**
 * TelemetryIntegration - Hub for external telemetry systems
 */
export declare class TelemetryIntegration {
    readonly id: string;
    private sinks;
    private buffer;
    private bufferSize;
    private flushInterval;
    private enabled;
    private flushTimer?;
    constructor(config?: TelemetryIntegrationConfig);
    /**
     * Add sink
     */
    addSink(sink: TelemetrySink): void;
    /**
     * Remove sink by name
     */
    removeSink(name: string): boolean;
    /**
     * Record event
     */
    event(name: string, data?: any, tags?: Record<string, string>): void;
    /**
     * Record metric
     */
    metric(name: string, value: number, tags?: Record<string, string>): void;
    /**
     * Record trace
     */
    trace(name: string, data: any, tags?: Record<string, string>): void;
    /**
     * Record log
     */
    log(name: string, data: any, tags?: Record<string, string>): void;
    /**
     * Record telemetry
     */
    private record;
    /**
     * Flush all buffered records
     */
    flush(): Promise<void>;
    /**
     * Close integration
     */
    close(): Promise<void>;
    /**
     * Enable/disable
     */
    setEnabled(enabled: boolean): void;
    /**
     * Start flush timer
     */
    private startFlushTimer;
    /**
     * Stop flush timer
     */
    private stopFlushTimer;
    /**
     * Get stats
     */
    getStats(): {
        sinkCount: number;
        bufferSize: number;
        enabled: boolean;
    };
}
/**
 * Create telemetry integration
 */
export declare function createTelemetryIntegration(config?: TelemetryIntegrationConfig): TelemetryIntegration;
/**
 * Create console sink
 */
export declare function createConsoleSink(format?: 'json' | 'pretty'): ConsoleSink;
/**
 * Create HTTP sink
 */
export declare function createHTTPSink(endpoint: string, options?: {
    headers?: Record<string, string>;
    batchSize?: number;
}): HTTPSink;
export default TelemetryIntegration;