anon-identity/dist/agent/delegation-policy-engine.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

import { AgentIdentity, AgentDelegationOptions, ScopeReductionPolicy, ExpirationPolicy, DelegationContext } from './types';
import { AgentIdentityManager } from './agent-identity';
export interface DelegationPolicy {
    id: string;
    name: string;
    description: string;
    maxDepth: number;
    scopeReduction: ScopeReductionPolicy;
    expirationPolicy: ExpirationPolicy;
    constraints?: DelegationConstraints;
    enabled: boolean;
}
export interface DelegationConstraints {
    allowedServices?: string[];
    deniedServices?: string[];
    maxScopes?: number;
    requiredScopes?: string[];
    timeOfDayRestrictions?: TimeRestriction[];
    ipWhitelist?: string[];
    customConstraints?: Array<(context: DelegationContext) => boolean>;
}
export interface TimeRestriction {
    startHour: number;
    endHour: number;
    timezone: string;
    daysOfWeek?: number[];
}
export interface PolicyEvaluationResult {
    allowed: boolean;
    policy?: DelegationPolicy;
    violations: string[];
    warnings: string[];
    appliedConstraints: string[];
}
export declare class DelegationPolicyEngine {
    private agentManager;
    private policies;
    private globalMaxDepth;
    private defaultPolicy;
    constructor(agentManager: AgentIdentityManager);
    /**
     * Sets the global maximum delegation depth
     */
    setGlobalMaxDepth(depth: number): void;
    /**
     * Registers a delegation policy
     */
    registerPolicy(policy: DelegationPolicy): void;
    /**
     * Evaluates whether a delegation is allowed based on policies
     */
    evaluatePolicy(context: DelegationContext, policyId?: string): Promise<PolicyEvaluationResult>;
    /**
     * Creates a delegation options object based on policy
     */
    createDelegationOptions(policy: DelegationPolicy, parentAgent: AgentIdentity): AgentDelegationOptions;
    /**
     * Applies expiration policy to determine credential expiration
     */
    calculateExpiration(policy: DelegationPolicy, parentExpiration: Date): Date;
    /**
     * Validates that a delegation request complies with all policies
     */
    validateDelegationRequest(parentAgentDID: string, requestedScopes: string[], serviceDID?: string): Promise<{
        valid: boolean;
        errors: string[];
        maxDepth?: number;
    }>;
    private createDefaultPolicy;
    private initializeBuiltInPolicies;
    private findApplicablePolicy;
    private getParentScopes;
    private evaluateConstraints;
    private isTimeAllowed;
    /**
     * Exports all registered policies
     */
    exportPolicies(): DelegationPolicy[];
    /**
     * Imports policies from an array
     */
    importPolicies(policies: DelegationPolicy[]): void;
    /**
     * Gets a specific policy by ID
     */
    getPolicy(policyId: string): DelegationPolicy | undefined;
    /**
     * Updates an existing policy
     */
    updatePolicy(policyId: string, updates: Partial<DelegationPolicy>): void;
    /**
     * Enables or disables a policy
     */
    setPolicyEnabled(policyId: string, enabled: boolean): void;
}
//# sourceMappingURL=delegation-policy-engine.d.ts.map