/**
 * AI Guard SDK - Main runtime API
 *
 * Entry point for integrating dynamic security scanning into LLM applications.
 * Provides middleware hooks for capturing requests/responses and emitting findings.
 */
import type { AccessAuditEntry, AuditLogEntry, SDKConfig, CapturedRequest, CapturedResponse, ModelMetadata, DynamicFinding, FindingFeedbackResult, FindingFeedbackVerdict, SDKStats } from "./types";
/**
 * AI Guard SDK instance.
 * Manages runtime security scanning in observe-only mode.
 */
export declare class AIGuardSDK {
    private config;
    private evaluator;
    private enabled;
    private readonly privacyControls;
    private readonly accessAuditTrail;
    private readonly auditSink;
    private feedbackRefreshTimer;
    private activeRulePack;
    /** Track in-flight transmission promises so dispose() / waitForTransmission() can await them. */
    private readonly _pendingTransmissions;
    constructor(config?: SDKConfig);
    /**
     * Performs observe-only scanning of a request/response cycle.
     * Never blocks execution; findings are emitted to configured callback.
     *
     * @returns DynamicFinding[] - Findings emitted during this evaluation
     */
    scanRequestResponse(request: CapturedRequest, response: CapturedResponse, model: ModelMetadata): Promise<DynamicFinding[]>;
    /**
     * Performs incremental scanning for streaming response windows.
     * This is used by middleware to detect abuse before stream completion.
     */
    scanStreamChunk(request: CapturedRequest, partialResponseText: string, model: ModelMetadata): Promise<DynamicFinding[]>;
    /**
     * Determines if this request should be sampled based on configuration.
     */
    private shouldSample;
    private extractSessionId;
    private headerValue;
    private routePath;
    private emitRuntimeFindingsAndSpans;
    /**
     * Enable or disable the SDK at runtime.
     */
    setEnabled(enabled: boolean): void;
    /**
     * Wait for all in-flight transmissions to complete (with a timeout).
     * Call this before process exit to ensure findings reach the dashboard.
     *
     * @param timeoutMs Maximum time to wait (default 10 seconds).
     * @returns The number of transmissions that were still pending when the timeout fired.
     */
    waitForTransmission(timeoutMs?: number): Promise<number>;
    dispose(): void;
    /** Track an async transmission so waitForTransmission() / dispose() can await it. */
    private _track;
    /**
     * Gets current SDK status.
     */
    isEnabled(): boolean;
    /**
     * Gets runtime statistics.
     */
    getStats(): SDKStats;
    /**
     * Resets runtime statistics.
     */
    resetStats(): void;
    /**
     * Gets diagnostic information.
     */
    getDiagnostics(): {
        enabled: boolean;
        rulesLoaded: number;
        stats: SDKStats;
        config: {
            environment: string;
            evaluationTimeoutMs: number;
            sampleRatePercent: number;
            capturePayloads: boolean;
            enforcementMode: string;
            canaryPercentage: number;
            routePinnedCount: number;
            circuitBreakerMode: string;
            classifierEnabled: boolean;
            classifierThreshold?: number;
            classifierTimeoutMs?: number;
            streamScanWindowTokens: number;
            runtimeMeteringEnabled: boolean;
            remoteFeedbackEnabled: boolean;
            remoteFeedbackChannel?: string;
            activeRulePackId?: string;
            toolAuthorizationEnabled: boolean;
            sessionRiskTrackingEnabled: boolean;
        };
        runtimeEventPipeline: {
            workerCount: number;
            maxQueueSize: number;
            peakQueueDepth: number;
            enqueued: number;
            processed: number;
            retries: number;
            deadLetters: number;
            backpressureRejects: number;
        };
        privacyControls: {
            retentionMaxEntries?: number;
            retentionMaxAgeMs?: number;
            tenantIsolationEnabled?: boolean;
        };
        transmission: {
            platformConfigured: boolean;
            signingKeyConfigured: boolean;
            canTransmitFindings: boolean;
            canTransmitSpans: boolean;
            auditSinkType: string;
        };
    };
    private recordRuntimeMetering;
    private startFeedbackRefreshLoop;
    private computeRulePackSignature;
    private normalizeChannel;
    private verifyRulePack;
    private syncRemoteRulePack;
    private syncRemoteFeedbackPriors;
    /**
     * Gets decision audit entries collected during this SDK lifecycle.
     */
    getAuditLogs(): readonly AuditLogEntry[];
    getAuditLogsForTenant(requestingTenantId: string, targetTenantId?: string): readonly AuditLogEntry[];
    deleteAuditLogsForTenant(requestingTenantId: string, targetTenantId?: string): number;
    getAccessAuditTrail(): readonly AccessAuditEntry[];
    scrubForLog(input: string): string;
    submitFeedback(findingId: string, verdict: FindingFeedbackVerdict): FindingFeedbackResult | null;
    submitFeedbackDetailed(input: {
        findingId?: string;
        ruleId?: string;
        verdict: FindingFeedbackVerdict;
        note?: string;
        expectedBehavior?: string;
        missedAttackSummary?: string;
        evidenceSnippet?: string;
    }): Promise<{
        accepted: boolean;
        feedbackId?: string;
        queued?: boolean;
        offline?: boolean;
        local?: FindingFeedbackResult | null;
    }>;
    private submitRemoteFeedback;
    private recordAccessAudit;
}
/**
 * Gets the global SDK instance, initializing if necessary.
 */
export declare function getSDK(config?: SDKConfig): AIGuardSDK;
/**
 * Resets the global SDK instance (useful for testing).
 */
export declare function resetSDK(): void;