/**
 * Security policy interface for automatic risk-based Xorida activation.
 *
 * Determines when to apply information-theoretic security (XorIDA split-channel)
 * vs standard encrypted transport based on action semantics and parameters.
 *
 * Design principle: Security should be invisible to users. The policy classifies
 * risk automatically so developers don't need to understand threshold cryptography.
 */
/** Security mode selected by policy. */
export type SecurityMode = {
    readonly type: 'standard';
} | {
    readonly type: 'split';
    readonly shares: number;
    readonly threshold: number;
} | {
    readonly type: 'xchange';
};
/** Explicit security level override (user-facing). */
export type SecurityLevel = 'auto' | 'standard' | 'high' | 'critical';
/** Context for security classification. */
export interface SecurityContext {
    /** Action being performed (e.g., 'transfer', 'execute', 'send'). */
    readonly action: string;
    /** Action parameters (amount, recipient, scope, etc.). */
    readonly params: Record<string, unknown>;
    /** Sender DID. */
    readonly sender: string;
    /** Recipient DID. */
    readonly recipient: string;
    /** Permission scope. */
    readonly scope: string;
    /** Explicit security level override (if provided by user). */
    readonly securityOverride?: SecurityLevel;
}
/** Reason why a particular security mode was selected. */
export interface SecurityDecision {
    /** Selected security mode. */
    readonly mode: SecurityMode;
    /** Human-readable reason for this decision. */
    readonly reason: string;
    /** Whether this was an auto-decision or explicit override. */
    readonly wasOverridden: boolean;
}
/**
 * Security policy interface.
 *
 * Implementations classify actions into security modes based on risk.
 * Used by Agent.send() to automatically apply Xorida when needed.
 */
export interface SecurityPolicy {
    /**
     * Classify an action into a security mode.
     *
     * @param context - Action context (action, params, sender, recipient, scope)
     * @returns Security decision with mode and reason
     */
    classify(context: SecurityContext): SecurityDecision;
}
/**
 * Default security policy for basic XBind.
 *
 * Rules:
 * - Explicit risk tags: low → 2-of-2, medium → 2-of-3, high/critical → 3-of-5
 * - Fiat transfers: USD/EUR/GBP >$100k → 2-of-3, >$1M → 3-of-5
 * - Crypto transfers: Require explicit risk tag (no numeric auto-detection)
 * - Sensitive scopes: custody/admin/settlement → 2-of-3
 * - Cross-entity communication: 2-of-3
 * - Explicit 'high' override: 2-of-3, 'critical' override: 3-of-5
 * - Everything else: Standard encrypted transport (V3 hybrid PQ)
 *
 * Enterprise and Government variants extend this with custom rules.
 */
export declare class DefaultSecurityPolicy implements SecurityPolicy {
    private readonly options;
    /**
     * Create a default security policy.
     *
     * @param options - Optional configuration
     * @param options.highValueThreshold - Amount threshold for high security (default: 100000)
     * @param options.criticalValueThreshold - Amount threshold for critical security (default: 1000000)
     * @param options.enableXchange - Allow Xchange mode for performance (default: false)
     */
    constructor(options?: {
        readonly highValueThreshold?: number;
        readonly criticalValueThreshold?: number;
        readonly enableXchange?: boolean;
    });
    classify(context: SecurityContext): SecurityDecision;
}
/**
 * Security mode description with multiple format representations.
 */
export interface SecurityModeDescription {
    /** Security mode type. */
    readonly type: 'standard' | 'split' | 'xchange';
    /** Security level classification. */
    readonly level: 'standard' | 'high' | 'critical' | 'performance';
    /** Share configuration (only for split mode). */
    readonly shares?: {
        readonly total: number;
        readonly threshold: number;
    };
    /** Multiple format representations. */
    readonly formats: {
        readonly multiline: string;
        readonly singleline: string;
        readonly json: string;
        readonly markdown: string;
    };
}
/**
 * Get a human-readable security mode description.
 *
 * Used for logging and user feedback.
 *
 * @param mode - Security mode
 * @returns User-friendly description
 *
 * @deprecated Use describeSecurityModeStructured() for new code. This function remains for backward compatibility.
 */
export declare function describeSecurityMode(mode: SecurityMode): string;
/**
 * Get a structured security mode description with multiple formats.
 *
 * Returns an object with the security classification and formatted descriptions
 * optimized for different use cases (display, logging, APIs, docs).
 *
 * @param mode - Security mode
 * @returns Security mode description with formats
 *
 * @example
 * ```typescript
 * const mode: SecurityMode = { type: 'split', shares: 3, threshold: 2 };
 * const description = describeSecurityModeStructured(mode);
 *
 * console.log(description.formats.singleline);
 * // "high | split | 2-of-3"
 *
 * console.log(description.formats.multiline);
 * // "Security Level: High
 * //  Mode: Split-channel (XorIDA)
 * //  Shares: 3 total, 2 required"
 *
 * console.log(description.shares);
 * // { total: 3, threshold: 2 }
 * ```
 */
export declare function describeSecurityModeStructured(mode: SecurityMode): SecurityModeDescription;
