import { O as OutputGuardrail, A as AIResult } from '../types-C7t6e3EI.cjs';
import 'ai';
import '@ai-sdk/provider';

type UsageRecord = Record<string, unknown> | undefined;
interface ContentExtraction {
    text: string;
    object: unknown;
    usage?: {
        promptTokens?: number;
        completionTokens?: number;
        totalTokens?: number;
    };
    finishReason?: string;
    generationTimeMs?: number;
    reasoningText?: string;
}
declare function extractContent(result: AIResult): ContentExtraction;
declare function stringifyContent(text?: string, object?: unknown, accumulatedText?: string): string;
interface NormalizedUsage {
    promptTokens?: number;
    completionTokens?: number;
    totalTokens?: number;
}
declare function normalizeUsage(usage: UsageRecord): NormalizedUsage | undefined;
declare const outputLengthLimit: (maxLength: number) => OutputGuardrail;
declare const minLengthRequirement: (minLength: number) => OutputGuardrail;
declare const sensitiveDataFilter: () => OutputGuardrail;
declare const blockedContent: (words: string[]) => OutputGuardrail;
declare const jsonValidation: () => OutputGuardrail;
declare const confidenceThreshold: (minConfidence: number) => OutputGuardrail;
declare const toxicityFilter: (threshold?: number) => OutputGuardrail;
type CustomOutputValidationInput = {
    text?: string;
    object?: unknown;
    usage?: {
        promptTokens?: number;
        completionTokens?: number;
        totalTokens?: number;
    };
    finishReason?: string;
    generationTimeMs?: number;
};
type CustomOutputValidationFn = (payload: CustomOutputValidationInput) => boolean;
declare const customValidation: (name: string, validator: CustomOutputValidationFn, message: string) => OutputGuardrail;
declare const schemaValidation: (schema: {
    parse: (obj: unknown) => unknown;
}) => OutputGuardrail;
/**
 * Per-request token ceiling — trips when a *single* response exceeds `maxTokens`.
 *
 * For a *cumulative* session limit (total tokens/cost across many calls), use
 * {@link budgetGuardrail} with a shared budget instead, so spend is tracked in
 * one place rather than re-summed per request.
 */
declare const tokenUsageLimit: (maxTokens: number) => OutputGuardrail;
declare const performanceMonitor: (maxGenerationTimeMs: number) => OutputGuardrail;
declare const hallucinationDetector: (confidenceThreshold?: number) => OutputGuardrail;
declare const biasDetector: () => OutputGuardrail;
declare const factualAccuracyChecker: (requireSources?: boolean) => OutputGuardrail;
declare const privacyLeakageDetector: () => OutputGuardrail;
declare const contentConsistencyChecker: (referenceContent?: string) => OutputGuardrail;
declare const complianceChecker: (regulations?: string[]) => OutputGuardrail;
/**
 * Secret redaction guardrail that detects and blocks output containing sensitive information
 * like API keys, access tokens, AWS ARNs, JWTs, and PEM certificates
 */
declare const secretRedaction: OutputGuardrail<Record<string, unknown>>;
/**
 * Enhanced unsafe content detector that flags potentially harmful, inappropriate, or prohibited content
 */
declare const unsafeContentDetector: OutputGuardrail<Record<string, unknown>>;
/**
 * Cost and quota rails guardrail to monitor token usage and costs
 */
/**
 * Per-request cost/token quota — trips when a *single* response exceeds the
 * given per-request limits.
 *
 * For a *cumulative* session budget (total cost/tokens across the whole run, with
 * an abort-signal kill-switch), use {@link budgetGuardrail} — it feeds each
 * call's usage into one shared budget (autotel-genai's `GenAiGuard` or the
 * built-in {@link createGuardrailBudget}), avoiding double-tracking.
 */
declare const costQuotaRails: (options: {
    maxTokensPerRequest?: number;
    maxCostPerRequest?: number;
    tokenCostPer1K?: number;
}) => OutputGuardrail;
/**
 * Enhanced hallucination/grounding checker with schema constraints and citation validation
 */
declare const enhancedHallucinationDetector: (options: {
    requireCitations?: boolean;
    citationFormats?: string[];
    factCheckPatterns?: string[];
    confidenceThreshold?: number;
    schemaConstraints?: {
        requiredFields?: string[];
        allowedValues?: {
            [field: string]: string[];
        };
    };
}) => OutputGuardrail;
/**
 * Retry-After integration guardrail that handles provider rate limiting and backoff
 */
declare const retryAfterIntegration: (options: {
    maxRetryDelayMs?: number;
    defaultBackoffMs?: number;
    jitterFactor?: number;
    trackRateLimits?: boolean;
}) => OutputGuardrail;

export { type NormalizedUsage, biasDetector, blockedContent, complianceChecker, confidenceThreshold, contentConsistencyChecker, costQuotaRails, customValidation, enhancedHallucinationDetector, extractContent, factualAccuracyChecker, hallucinationDetector, jsonValidation, minLengthRequirement, normalizeUsage, outputLengthLimit, performanceMonitor, privacyLeakageDetector, retryAfterIntegration, schemaValidation, secretRedaction, sensitiveDataFilter, stringifyContent, tokenUsageLimit, toxicityFilter, unsafeContentDetector };