/**
 * Dual Channel Enforcer - Control/Data Plane Separation
 *
 * Enforces separation between control plane (trusted instructions) and data plane
 * (processed content). Critical instructions must come from the control plane,
 * preventing injection attacks via the data plane.
 *
 * Features:
 * - Channel classification (control vs data)
 * - Data plane instruction stripping/sanitization
 * - Control plane source verification
 * - Audit logging for blocked instructions
 *
 * @packageDocumentation
 * @module @vorion/semantic-governance/dual-channel
 */
import { VorionError } from '../common/errors.js';
import type { DualChannelConfig, MessageChannel, MessageClassification, EnforcementResult } from './types.js';
/**
 * Error thrown when dual-channel enforcement fails
 */
export declare class DualChannelError extends VorionError {
    code: string;
    statusCode: number;
    constructor(message: string, details?: Record<string, unknown>);
}
/**
 * Default control plane sources
 */
export declare const DEFAULT_CONTROL_PLANE_SOURCES: string[];
/**
 * Default data plane sources
 */
export declare const DEFAULT_DATA_PLANE_SOURCES: string[];
/**
 * Dual Channel Enforcer
 *
 * Enforces separation between control and data planes.
 */
export declare class DualChannelEnforcer {
    private readonly config;
    private readonly controlPlaneSourceSet;
    /**
     * Create a new DualChannelEnforcer
     *
     * @param config - Dual-channel configuration
     */
    constructor(config: DualChannelConfig);
    /**
     * Enforce channel separation on a message
     *
     * @param message - Message content and metadata
     * @param channel - Classified channel (control or data)
     * @returns Enforcement result
     */
    enforceChannelSeparation(message: {
        content: string;
        source: string;
        authenticated: boolean;
    }, channel: MessageChannel): EnforcementResult;
    /**
     * Sanitize data plane content by removing/neutralizing instructions
     *
     * @param content - Content to sanitize
     * @returns Sanitized content
     */
    sanitizeDataPlane(content: string): string;
    /**
     * Check if a source is a control plane source
     *
     * @param source - Source identifier
     * @returns Whether the source is control plane
     */
    isControlPlaneSource(source: string): boolean;
    /**
     * Classify a message's channel
     *
     * @param message - Message to classify
     * @returns Channel classification
     */
    classifyMessage(message: {
        source: string;
        authenticated: boolean;
    }): MessageClassification;
    /**
     * Process a message with full classification and enforcement
     *
     * @param message - Message to process
     * @returns Processed result with classification and enforcement
     */
    processMessage(message: {
        content: string;
        source: string;
        authenticated: boolean;
    }): {
        classification: MessageClassification;
        enforcement: EnforcementResult;
    };
    /**
     * Add a control plane source
     *
     * @param source - Source to add
     */
    addControlPlaneSource(source: string): void;
    /**
     * Remove a control plane source
     *
     * @param source - Source to remove
     * @returns Whether the source was removed
     */
    removeControlPlaneSource(source: string): boolean;
    /**
     * Detect instructions in content
     *
     * @param content - Content to analyze
     * @returns Detection result
     */
    private detectInstructions;
}
/**
 * Create a DualChannelEnforcer with default configuration
 *
 * @returns DualChannelEnforcer with secure defaults
 */
export declare function createDefaultDualChannelEnforcer(): DualChannelEnforcer;
/**
 * Create a strict DualChannelEnforcer that blocks data plane instructions
 *
 * @returns DualChannelEnforcer with strict settings
 */
export declare function createStrictDualChannelEnforcer(): DualChannelEnforcer;
/**
 * Create a permissive DualChannelEnforcer that only warns
 *
 * @returns DualChannelEnforcer with permissive settings
 */
export declare function createPermissiveDualChannelEnforcer(): DualChannelEnforcer;
//# sourceMappingURL=dual-channel.d.ts.map