import type { ISecurityPolicy } from './ISecurityPolicy';
/**
 * Verification depth for capability tokens.
 *
 * - 'presence': Just check token exists (Phase 1)
 * - 'signature': Verify cryptographic signature (Phase 2)
 * - 'full-chain': Verify entire delegation chain (Phase 3)
 */
export type VerificationDepth = 'presence' | 'signature' | 'full-chain';
/**
 * Audit logging level.
 *
 * Vision 27 Section 7.3:
 * - 'none': No logging
 * - 'failures': Only denied/error outcomes (always logged)
 * - 'summary': Basic info (who, what, target, outcome)
 * - 'full': Complete event details with context
 */
export type AuditLevel = 'none' | 'failures' | 'summary' | 'full';
/**
 * How capabilities flow to children.
 *
 * - 'inherit': Child gets parent's capability
 * - 'attenuate': Child gets reduced capability
 * - 'fresh': Child gets newly minted capability
 */
export type CapabilityFlowPolicy = 'inherit' | 'attenuate' | 'fresh';
/**
 * Message routing for sibling communication.
 */
export type SiblingRouting = 'direct' | 'parent';
/**
 * Base fields present in ALL policy sections.
 */
export interface IPolicySectionBase {
    requireCapability: boolean;
}
/**
 * Inbound message verification (child-to-parent, external).
 */
export interface IInboundPolicySection extends IPolicySectionBase {
    verificationDepth: VerificationDepth;
    auditLevel: AuditLevel;
}
/**
 * Outbound policy (parent-to-child).
 * No verificationDepth - parent is inherently trusted.
 *
 * Carl Hewitt: "The parent created the child. Trust flows downward."
 */
export interface IOutboundPolicySection extends IPolicySectionBase {
    capabilityPolicy: CapabilityFlowPolicy;
}
/**
 * Sibling communication policy.
 */
export interface ISiblingPolicySection extends IPolicySectionBase {
    allowed: boolean;
    verificationDepth: VerificationDepth;
    routeThrough: SiblingRouting;
}
/**
 * External communication policy (outside the realm).
 */
export interface IExternalPolicySection extends IInboundPolicySection {
    /** Allowed source mount patterns (if specified, only these allowed) */
    allowedSources?: string[];
    /** Blocked source mount patterns (always rejected) */
    blockedSources?: string[];
}
/**
 * Full supervisor security policy.
 *
 * Each supervisor defines how security works within its realm.
 * See: Vision/27-SECURITY-FEDERATION-DRAFT.md Section 4.2
 *
 * Joe Armstrong: "Supervision tree = Security tree.
 * The supervisor that handles errors is the same entity
 * that enforces security policy for its children."
 */
export interface ISupervisorSecurityPolicy extends ISecurityPolicy {
    /** For messages FROM children (events bubbling up) */
    childToParent: IInboundPolicySection;
    /** For messages TO children (context flowing down) */
    parentToChild: IOutboundPolicySection;
    /** For messages BETWEEN siblings (lateral communication) */
    siblingToSibling: ISiblingPolicySection;
    /** For messages from OUTSIDE the realm */
    external: IExternalPolicySection;
    /** Delegation rules */
    delegation: {
        /** Maximum delegation chain length */
        maxChainLength: number;
        /** Allow delegation across realm boundaries */
        allowCrossRealm: boolean;
        /** Require attenuation on delegation */
        requireAttenuation: boolean;
    };
    /** Revocation configuration */
    revocation: {
        /** How often to check revocation status */
        checkFrequency: 'realtime' | 'cached';
        /** Maximum age of cached revocation status (ms) */
        cacheMaxAge: number;
        /** Propagate revocation to children */
        propagateToChildren: boolean;
    };
}
//# sourceMappingURL=ISupervisorSecurityPolicy.d.ts.map