/**
 * GeminiAdapter -- Google Gemini platform adapter for governance enforcement.
 *
 * Maps Gemini's function_calling format (functionCall.name / functionCall.args)
 * to the unified GovernanceAdapter interface. Supports Gemini tool declarations,
 * tool_config modes, and function_calling_config.
 *
 * Pure TypeScript -- no Google SDK dependency required.
 *
 * @connexum/ai-governance
 */
import { type GovernanceAdapter, type AdapterConfig, type ActionContext, type ActionDecision, type ActionResult, type AdapterCapabilities } from '../adapters/index';
/** Gemini function call as it appears in model responses. */
export interface GeminiFunctionCall {
    name: string;
    args: Record<string, unknown>;
}
/** A single Gemini tool declaration (subset of the API schema). */
export interface GeminiToolDeclaration {
    name: string;
    description?: string;
    parameters?: {
        type: string;
        properties?: Record<string, unknown>;
        required?: string[];
    };
}
/** Gemini tool_config modes that control function calling behavior. */
export type GeminiFunctionCallingMode = 'AUTO' | 'ANY' | 'NONE';
/** Gemini function_calling_config as sent in generation requests. */
export interface GeminiFunctionCallingConfig {
    mode: GeminiFunctionCallingMode;
    allowedFunctionNames?: string[];
}
/** Gemini tool_config wrapper. */
export interface GeminiToolConfig {
    functionCallingConfig: GeminiFunctionCallingConfig;
}
/** Result returned by wrapFunctionCall. */
export interface GovernedFunctionCallResult {
    allowed: boolean;
    decision: ActionDecision;
    functionCall: GeminiFunctionCall;
    context: ActionContext;
}
export interface GeminiAuditEntry {
    timestamp: string;
    functionName: string;
    decision: ActionDecision['type'];
    reason: string;
    agentName: string;
    durationMs?: number;
}
export declare class GeminiAdapter implements GovernanceAdapter {
    name: string;
    private config;
    private blockedFunctions;
    private allowedFunctions;
    private approvalRequiredFunctions;
    private toolDeclarations;
    private functionCallingMode;
    private modeAllowedNames;
    private auditLog;
    initialize(config: AdapterConfig): void;
    preAction(context: ActionContext): ActionDecision;
    postAction(context: ActionContext, result: ActionResult): void;
    getCapabilities(): AdapterCapabilities;
    /**
     * Convert a Gemini functionCall object to a unified ActionContext.
     */
    mapFunctionCallToContext(functionCall: GeminiFunctionCall, agentName?: string): ActionContext;
    /**
     * Wrap a Gemini function call with governance enforcement.
     *
     * This is the primary integration point: intercept a functionCall from
     * Gemini's response, run governance checks, and return the decision
     * alongside the normalized context.
     */
    wrapFunctionCall(functionCall: GeminiFunctionCall, agentName?: string): GovernedFunctionCallResult;
    /**
     * Register Gemini tool declarations for capability checking.
     */
    registerToolDeclarations(declarations: GeminiToolDeclaration[]): void;
    /**
     * Check if a function name is declared in the registered tools.
     */
    isFunctionDeclared(name: string): boolean;
    /**
     * Apply a Gemini function_calling_config to governance rules.
     */
    applyFunctionCallingConfig(config: GeminiFunctionCallingConfig): void;
    /**
     * Get the current function calling mode.
     */
    getFunctionCallingMode(): GeminiFunctionCallingMode;
    /**
     * Get the audit log.
     */
    getAuditLog(): ReadonlyArray<GeminiAuditEntry>;
    /**
     * Clear the audit log.
     */
    clearAuditLog(): void;
    private decide;
}
//# sourceMappingURL=gemini.d.ts.map