/**
 * Bindings Manager - Credential Isolation for Code-Mode
 * Phase 3: Hide API keys from sandboxed code
 * Phase 4 Enhancement: Per-binding network policies
 *
 * Implements Cloudflare Workers-style bindings pattern:
 * - Credentials stored securely in main thread only
 * - Worker receives pre-authenticated clients (bindings)
 * - Worker calls methods on bindings, never sees raw keys
 * - Main thread executes actual API calls with credentials
 * - Each binding can have custom network access rules
 */
import type { NetworkPolicy } from './network-policy.js';
/**
 * Binding definition - what the worker sees
 */
export interface Binding {
    name: string;
    type: 'http' | 'sdk' | 'database' | 'custom' | 'local-network';
    methods: string[];
    networkPolicy?: Partial<NetworkPolicy>;
}
/**
 * Credential definition - stored securely in main thread
 */
export interface Credential {
    mcpName: string;
    type: 'api_key' | 'oauth_token' | 'basic_auth' | 'custom';
    data: {
        apiKey?: string;
        token?: string;
        username?: string;
        password?: string;
        custom?: Record<string, any>;
    };
    updatedAt?: string;
}
/**
 * Binding execution request from worker
 */
export interface BindingExecutionRequest {
    bindingName: string;
    method: string;
    args: any[];
}
/**
 * Manages bindings and credential isolation
 */
export declare class BindingsManager {
    private credentials;
    private bindings;
    private authenticatedClients;
    private bindingNetworkPolicies;
    /**
     * Register a credential for an MCP
     * Credentials are stored securely in main thread only
     */
    registerCredential(credential: Credential): void;
    /**
     * Create a binding for an MCP
     * This is what the worker will receive (no credentials)
     */
    createBinding(mcpName: string, type: Binding['type'], methods: string[], networkPolicy?: Partial<NetworkPolicy>): Binding;
    /**
     * Get network policy for a specific binding
     * Returns undefined if binding has no custom policy (use default)
     */
    getBindingNetworkPolicy(bindingName: string): Partial<NetworkPolicy> | undefined;
    /**
     * Get all bindings to pass to worker
     * Returns binding definitions only (no credentials)
     */
    getBindingsForWorker(): Binding[];
    /**
     * Create authenticated client for an MCP
     * This happens in main thread with access to credentials
     */
    createAuthenticatedClient(mcpName: string, clientFactory: (credential: Credential) => any): void;
    /**
     * Execute a binding method call from worker
     * This runs in main thread with access to real credentials
     */
    executeBinding(request: BindingExecutionRequest): Promise<any>;
    /**
     * Get credential for an MCP (main thread only)
     * Never expose this to worker
     */
    getCredential(mcpName: string): Credential | undefined;
    /**
     * Remove credential and binding
     */
    removeBinding(mcpName: string): void;
    /**
     * Clear all bindings and credentials
     */
    clear(): void;
}
interface VaultCredentialMetadata {
    mcpName: string;
    type: Credential['type'];
    updatedAt?: string;
}
export declare class CredentialVault {
    private static instance;
    private credentials;
    private vaultDir;
    private vaultPath;
    private keyPath;
    private encryptionKey;
    private initialized;
    private initPromise;
    private constructor();
    static getInstance(): CredentialVault;
    private ensureInitialized;
    private initialize;
    private loadOrCreateKey;
    private deriveKey;
    private loadFromDisk;
    private encryptPayload;
    private decryptPayload;
    private persistVault;
    /**
     * Store a credential securely (encrypted at rest)
     */
    store(mcpName: string, credential: Credential): Promise<void>;
    /**
     * Retrieve a credential (decrypted transparently)
     */
    retrieve(mcpName: string): Promise<Credential | undefined>;
    /**
     * Remove a credential
     */
    remove(mcpName: string): Promise<boolean>;
    /**
     * List all stored credentials (metadata only, no sensitive data)
     */
    list(): Promise<VaultCredentialMetadata[]>;
}
export {};
//# sourceMappingURL=bindings-manager.d.ts.map