/**
 * @name policy/policy-engine
 * @description High-level policy engine for enforcing permissions and spend limits.
 *
 * Wraps the local and hybrid policy engines, loads default policies, and
 * provides a unified API for permission validation, spend-limit checks,
 * and runtime diagnostics.
 *
 * @module policy/policy-engine
 */
import type { SapMcpConfig, SapPolicy, SapPermission } from '../../core/src/types.js';
interface PermissionContext {
    amountSol?: number;
    toolName?: string;
    args?: Record<string, unknown>;
    programId?: string;
    destination?: string;
    user?: string;
}
/**
 * @name PolicyEngine
 * @description High-level policy engine combining default policies, config-based limits, and hybrid enforcement.
 *
 * Loads default policies at construction time, creates a `HybridPolicyEngine`
 * when configured, and exposes permission validation, spend-limit checks,
 * policy CRUD, and runtime status diagnostics.
 *
 * @method validatePermissions  — Validate a list of permission strings against the allowed-tools config.
 * @method checkPermission       — Check whether a single permission and optional context is allowed.
 * @method getRuntimeStatus      — Return current hybrid/Bento policy status for diagnostics.
 * @method getPolicy             — Retrieve a registered policy by id.
 * @method addPolicy             — Register a custom policy.
 *
 * @usedBy `server.ts`, `core/context.ts`
 */
export declare class PolicyEngine {
    private config;
    private policies;
    private hybridPolicyEngine;
    constructor(config: SapMcpConfig);
    /**
     * Validate permissions
     */
    validatePermissions(permissions: string[]): Promise<{
        valid: boolean;
        permissions: SapPermission[];
        errors?: string[];
    }>;
    /**
     * Check if action is allowed
     */
    checkPermission(permission: string, context?: PermissionContext): Promise<{
        allowed: boolean;
        reason?: string;
    }>;
    /**
     * Returns current hybrid/Bento policy status for diagnostics.
     */
    getRuntimeStatus(): {
        mode: string;
        bentoConfigured: boolean;
        bentoAvailable: boolean;
        localEngineActive: boolean;
    };
    private createHybridPolicyEngine;
    private checkHybridPolicy;
    /**
     * Get policy by ID
     */
    getPolicy(policyId: string): SapPolicy | undefined;
    /**
     * Add custom policy
     */
    addPolicy(policy: SapPolicy): void;
    /**
     * @name TradingPolicy
     * @description Trading-specific policy limits enforced at the builder level.
     * Prevents catastrophic loss from agent parameter errors.
     */
    getTradingPolicy(): TradingPolicy;
    /**
     * @name validateTradingPolicy
     * @description Validate trading parameters against policy limits.
     * Called by Adrena builders before constructing the transaction.
     */
    validateTradingPolicy(params: TradingPolicyParams): PolicyViolationResult;
}
/** Trading-specific policy limits. */
export interface TradingPolicy {
    maxCollateralUsdPerTrade: number;
    maxLeverage: number;
    maxOpenPositions: number;
    allowedMarkets: string[];
    stopLossRequired: boolean;
    maxSlippageBps: number;
    requireHumanAckAboveUsd: number;
    /** Daily loss limit in USD. New trades are blocked when exceeded. */
    dailyLossLimitUsd?: number;
    /** Max drawdown percentage before blocking new trades. */
    maxDrawdownPct?: number;
    /** Cooldown in minutes after a losing trade. */
    cooldownMinutes?: number;
}
/** Parameters for trading policy validation. */
export interface TradingPolicyParams {
    market: string;
    side: string;
    collateralUsd: number;
    leverage: number;
    hasStopLoss: boolean;
    slippageBps?: number;
}
/** Result of trading policy validation. */
export interface PolicyViolationResult {
    allowed: boolean;
    violation?: string;
    message?: string;
    field?: string;
    max?: number;
    received?: number;
    threshold?: number;
    allowed_list?: string[];
}
export {};
//# sourceMappingURL=policy-engine.d.ts.map