import { UniversalRedactionConfig, UniversalRedactionResult } from './base/index.js';

declare class UniversalProvider {
    private redactor;
    private config;
    constructor(config?: UniversalRedactionConfig);
    redact(input: unknown): UniversalRedactionResult;
    redactBatch(inputs: unknown[]): Promise<UniversalRedactionResult[]>;
    updateConfig(newConfig: Partial<UniversalRedactionConfig>): void;
    getConfig(): UniversalRedactionConfig;
    private extractContent;
    private redactMetadata;
    private transformMetadata;
    private normalizeConfig;
}

declare abstract class BaseAdapter<TInput = unknown, TOutput = unknown> {
    protected provider: UniversalProvider;
    abstract readonly providerName: string;
    abstract readonly version: string;
    constructor(config?: UniversalRedactionConfig);
    abstract transform(input: TInput): Promise<TOutput> | TOutput;
    updateConfig(newConfig: Partial<UniversalRedactionConfig>): void;
    getConfig(): UniversalRedactionConfig;
}

interface Document {
    pageContent: string;
    metadata: Record<string, unknown>;
    id?: string;
}
declare class LangChainAdapter extends BaseAdapter<Document[] | string, Document[] | string> {
    readonly providerName = "langchain";
    readonly version = "3.0.0";
    transform(input: Document[] | string): Promise<Document[] | string>;
    createDocumentTransformer(): (documents: Document[]) => Promise<Document[]>;
    createRunnable(): Promise<unknown>;
    createRunnableWithMetadata(): Promise<unknown>;
    createDocumentTransform(): Promise<unknown>;
}
declare function createLangChainAdapter(config?: UniversalRedactionConfig): LangChainAdapter;

interface BaseNode {
    getText(): string;
    clone(options?: {
        text?: string;
        metadata?: Record<string, unknown>;
    }): BaseNode;
    getMetadata(): Record<string, unknown>;
    getNodeId(): string;
    setContent(content: string): void;
}
interface NodeTransformation {
    transform(nodes: BaseNode[]): Promise<BaseNode[]>;
}
declare class LlamaIndexAdapter extends BaseAdapter<BaseNode[] | string, BaseNode[] | string> {
    readonly providerName = "llamaindex";
    readonly version = "5.0.0";
    transform(input: BaseNode[] | string): Promise<BaseNode[] | string>;
    createNodeTransformer(): {
        transform: (nodes: BaseNode[]) => Promise<BaseNode[]>;
    };
    createTransformComponent(): {
        transformNodes: (nodes: BaseNode[]) => Promise<BaseNode[]>;
    };
    createTransformation(): Promise<NodeTransformation>;
    createPreprocessor(): Promise<unknown>;
}
declare function createLlamaIndexAdapter(config?: UniversalRedactionConfig): LlamaIndexAdapter;

interface StreamTextOptions {
    model: unknown;
    prompt: string;
    messages?: Array<{
        role: string;
        content: string;
    }>;
    system?: string;
    maxTokens?: number;
    temperature?: number;
    [key: string]: unknown;
}
interface StreamObjectOptions {
    model: unknown;
    prompt: string;
    schema: unknown;
    system?: string;
    [key: string]: unknown;
}
interface GenerateTextOptions {
    model: unknown;
    prompt?: string;
    messages?: Array<{
        role: string;
        content: string;
    }>;
    system?: string;
    tools?: Record<string, unknown>;
    [key: string]: unknown;
}
interface Tool {
    description?: string;
    parameters: unknown;
    execute: (params: unknown) => Promise<unknown> | unknown;
}
declare class VercelAIAdapter extends BaseAdapter<unknown, unknown> {
    readonly providerName = "vercel-ai";
    readonly version = "3.0.0";
    transform(input: unknown): Promise<unknown>;
    createStreamingWrapper(): {
        streamText: (options: StreamTextOptions) => Promise<unknown>;
        streamObject: (options: StreamObjectOptions) => Promise<unknown>;
        generateText: (options: GenerateTextOptions) => Promise<unknown>;
    };
    createToolWrapper(tools: Record<string, Tool>): Record<string, Tool>;
    createMessageCleaner(): {
        cleanMessage: (message: {
            role: string;
            content: string;
        }) => {
            role: string;
            content: string;
        };
        cleanMessages: (messages: Array<{
            role: string;
            content: string;
        }>) => Array<{
            role: string;
            content: string;
        }>;
    };
}
declare function createVercelAIAdapter(config?: UniversalRedactionConfig): VercelAIAdapter;

interface ChatMessage {
    role: "system" | "user" | "assistant" | "tool" | "function";
    content: string | null;
    name?: string;
    tool_calls?: unknown[];
    tool_call_id?: string;
}
interface ChatCompletionOptions {
    model: string;
    messages: ChatMessage[];
    functions?: unknown[];
    tools?: unknown[];
    temperature?: number;
    max_tokens?: number;
    [key: string]: unknown;
}
interface CompletionOptions$1 {
    model: string;
    prompt: string | string[];
    max_tokens?: number;
    temperature?: number;
    [key: string]: unknown;
}
interface EmbeddingOptions {
    model: string;
    input: string | string[];
    [key: string]: unknown;
}
interface AssistantMessage {
    role: "user" | "assistant";
    content: string;
    file_ids?: string[];
    metadata?: Record<string, unknown>;
}
declare class OpenAIAdapter extends BaseAdapter<unknown, unknown> {
    readonly providerName = "openai";
    readonly version = "4.0.0";
    transform(input: unknown): Promise<unknown>;
    createClientWrapper(openai: unknown): {
        chat: {
            completions: {
                create: (options: ChatCompletionOptions) => Promise<unknown>;
            };
        };
        completions: {
            create: (options: CompletionOptions$1) => Promise<unknown>;
        };
        embeddings: {
            create: (options: EmbeddingOptions) => Promise<unknown>;
        };
    };
    createAssistantWrapper(openai: unknown): {
        beta: {
            threads: {
                messages: {
                    create: (threadId: string, message: AssistantMessage) => Promise<unknown>;
                };
                runs: {
                    create: (threadId: string, options: {
                        assistant_id: string;
                        instructions?: string;
                        [key: string]: unknown;
                    }) => Promise<unknown>;
                };
            };
        };
    };
    createFunctionCallCleaner(): {
        cleanFunctionCall: (functionCall: {
            name: string;
            arguments: string;
        }) => {
            name: string;
            arguments: string;
        };
        cleanToolCall: (toolCall: {
            function: {
                name: string;
                arguments: string;
            };
            [key: string]: unknown;
        }) => {
            function: {
                name: string;
                arguments: string;
            };
            [key: string]: unknown;
        };
    };
    createMessageProcessor(): {
        processMessages: (messages: ChatMessage[]) => ChatMessage[];
        processSystemMessage: (content: string) => string;
        processUserMessage: (content: string) => string;
    };
}
declare function createOpenAIAdapter(config?: UniversalRedactionConfig): OpenAIAdapter;

interface ClaudeMessage {
    role: "user" | "assistant";
    content: string | Array<{
        type: string;
        text?: string;
        [key: string]: unknown;
    }>;
}
interface MessageOptions {
    model: string;
    messages: ClaudeMessage[];
    system?: string;
    max_tokens: number;
    temperature?: number;
    tools?: unknown[];
    tool_choice?: unknown;
    [key: string]: unknown;
}
interface CompletionOptions {
    model: string;
    prompt: string;
    max_tokens_to_sample: number;
    temperature?: number;
    [key: string]: unknown;
}
declare class AnthropicAdapter extends BaseAdapter<unknown, unknown> {
    readonly providerName = "anthropic";
    readonly version = "0.24.0";
    transform(input: unknown): Promise<unknown>;
    createClientWrapper(anthropic: unknown): {
        messages: {
            create: (options: MessageOptions) => Promise<unknown>;
            stream: (options: MessageOptions) => Promise<unknown>;
        };
        completions: {
            create: (options: CompletionOptions) => Promise<unknown>;
        };
    };
    private processContent;
    createToolCallProcessor(): {
        processToolCall: (toolCall: {
            name: string;
            input: Record<string, unknown>;
        }) => {
            name: string;
            input: Record<string, unknown>;
        };
    };
    createMessageProcessor(): {
        processMessage: (message: ClaudeMessage) => ClaudeMessage;
        processMessages: (messages: ClaudeMessage[]) => ClaudeMessage[];
        processSystemPrompt: (system: string) => string;
    };
    createConversationCleaner(): {
        cleanConversation: (messages: ClaudeMessage[], systemPrompt?: string) => {
            messages: ClaudeMessage[];
            system?: string;
        };
    };
    createStreamingWrapper(): {
        createStreamingMessage: (options: MessageOptions) => Promise<MessageOptions>;
    };
}
declare function createAnthropicAdapter(config?: UniversalRedactionConfig): AnthropicAdapter;

export { UniversalProvider, UniversalRedactionConfig, UniversalRedactionResult, createAnthropicAdapter, createLangChainAdapter, createLlamaIndexAdapter, createOpenAIAdapter, createVercelAIAdapter };