type SupportFlag = boolean | "unknown" | "conditional";
export type UnifiedChatRole = "system" | "user" | "assistant" | "tool" | "developer";
export interface UnifiedChatMessage {
    role: UnifiedChatRole;
    content: string;
}
export interface UnifiedChatCompletionsLikeRequest {
    model: string;
    messages: UnifiedChatMessage[];
    max_tokens?: number;
    temperature?: number;
    top_p?: number;
    frequency_penalty?: number;
    presence_penalty?: number;
    stop?: string[] | string;
    reasoning_effort?: "none" | "minimal" | "low" | "medium" | "high";
    extra?: Record<string, any>;
}
export type ProviderKey = "openai" | "anthropic" | "google" | "groq" | "xai" | "moonshot_kimi";
export type ApiVariantKey = string;
export interface Target {
    provider: ProviderKey;
    apiVariant?: ApiVariantKey;
    responseMode?: "standard" | "stream";
}
export interface Registry {
    schemaVersion: string;
    defaults: {
        modelResolutionOrder: Array<"exact" | "pattern" | "providerApiDefault" | "providerDefault">;
        messageJoin: {
            betweenChunks: string;
        };
    };
    providers: Record<ProviderKey, {
        apiVariants: Record<string, {
            tokenParam: string;
            messagesParam?: string;
            systemParam?: string;
            stopParam?: string;
            reasoningEffortParamPath?: string;
            samplingParams?: Partial<Record<"temperature" | "top_p", string>>;
            endpointStyle?: string;
        }>;
        providerDefaults: {
            defaultApiVariant: string;
            supports: {
                sampling?: {
                    temperature?: SupportFlag;
                    top_p?: SupportFlag;
                };
                penalties?: {
                    frequency_penalty?: SupportFlag;
                    presence_penalty?: SupportFlag;
                };
                stop?: SupportFlag;
                reasoningEffort?: SupportFlag;
            };
            rules?: {
                mutualExclusion?: Array<{
                    appliesToModelRegex: string;
                    params: Array<"temperature" | "top_p">;
                }>;
            };
            streaming?: Partial<Record<string, {
                supported: boolean;
                streamParam?: string;
                protocol?: "sse" | "jsonl" | "websocket";
            }>>;
        };
        patterns?: Array<{
            match: {
                prefix?: string;
                regex?: string;
            };
            caps: {
                defaultApiVariant?: string;
                supports?: any;
            };
        }>;
        models?: Record<string, {
            defaultApiVariant?: string;
            supports?: any;
        }>;
    }>;
}
export declare function joinHuman(chunks: string[], betweenChunks?: string): string;
export declare function mapRoleMessagesToRecord(input: Array<{
    role: string;
    messages: string;
}>, mapping: Array<{
    role: string;
    propertyName: string;
}>, betweenChunks?: string): Record<string, any>;
export declare function resolveModelCaps(registry: Registry, provider: ProviderKey, model: string): {
    defaultApiVariant: string;
    supports: any;
    rules?: any;
};
export interface BuiltRequest {
    provider: ProviderKey;
    apiVariant: string;
    request: Record<string, any>;
    response: {
        mode: "standard" | "stream";
        protocol?: "sse" | "jsonl" | "websocket";
    };
    modelFix?: import('./model-fixer').FixModelResult;
}
export interface TransformOptions {
    fixModel?: {
        aliases: import('./model-fixer').ModelAliasesJson;
        normalization: import('./model-fixer').ModelNormalizationJson;
        options?: import('./model-fixer').FixModelOptions;
    };
}
export declare function transformUnifiedRequest(unified: UnifiedChatCompletionsLikeRequest, target: Target, registry: Registry, options?: TransformOptions): BuiltRequest;
export {};
//# sourceMappingURL=chat-style-transformer.d.ts.map