@openagentid/aegis-sdk/core

interface ActiveHours {
    startHour: number;
    endHour: number;
    timezone: string;
}

declare const ActiveHoursSchema: z.ZodObject<{
    startHour: z.ZodNumber;
    endHour: z.ZodNumber;
    timezone: z.ZodString;
}, "strip", z.ZodTypeAny, {
    startHour: number;
    endHour: number;
    timezone: string;
}, {
    startHour: number;
    endHour: number;
    timezone: string;
}>;

type AegisError = ResolverError | AuthError | PolicyError | VerificationError | KeyError | DelegationError | WalletError;

declare class AegisException extends Error {
    readonly error: AegisError;
    constructor(error: AegisError);
}

interface AegisIdentity {
    did: string;
    identityType: IdentityType;
    displayName?: string | null;
    conformanceLevel?: number | null;
}

interface AgentLineageProof {
    type: string;
    verificationMethod: string;
    created: string;
    jws: string;
}

interface AuditInfo {
    auditId: string;
    timestamp: string;
    engine: string;
    policiesEvaluated: string[];
}

interface AuthContext {
    provider: string;
    subject: string;
    did?: string | null;
    sessionId?: string | null;
    expiresAt?: string | null;
    claims: Record<string, unknown>;
}

type AuthCredential = {
    type: "bearer_token";
    token: string;
} | {
    type: "session_cookie";
    cookie: string;
} | {
    type: "api_key";
    key: string;
} | {
    type: "signed_challenge";
    did: string;
    challenge: string;
    signature: string;
    timestamp: string;
    nonce: string;
} | {
    type: "capability_token";
    token: string;
} | {
    type: "passkey_assertion";
    credentialId: string;
    authenticatorData: string;
    clientDataJson: string;
    signature: string;
} | {
    type: "custom";
    provider: string;
    data: unknown;
};

type AuthError = {
    kind: "auth/invalid_credential";
    reason: string;
    message: string;
} | {
    kind: "auth/credential_expired";
    expiredAt: string;
    message: string;
} | {
    kind: "auth/session_revoked";
    sessionId: string;
    message: string;
} | {
    kind: "auth/session_expired";
    sessionId: string;
    message: string;
} | {
    kind: "auth/challenge_invalid";
    reason: string;
    message: string;
} | {
    kind: "auth/provider_unavailable";
    provider: string;
    message: string;
} | {
    kind: "auth/refresh_not_supported";
    provider: string;
    message: string;
} | {
    kind: "auth/revocation_not_supported";
    provider: string;
    message: string;
} | {
    kind: "auth/internal";
    reason: string;
    message: string;
};

declare const authErrors: {
    invalidCredential: (reason: string) => AuthError;
    credentialExpired: (expiredAt: string) => AuthError;
    sessionRevoked: (sessionId: string) => AuthError;
    sessionExpired: (sessionId: string) => AuthError;
    challengeInvalid: (reason: string) => AuthError;
    providerUnavailable: (provider: string) => AuthError;
    refreshNotSupported: (provider: string) => AuthError;
    revocationNotSupported: (provider: string) => AuthError;
    internal: (reason: string) => AuthError;
};

interface AuthProvider {
    validate(credential: AuthCredential): Promise<AuthContext>;
    getIdentity(ctx: AuthContext): Promise<AegisIdentity>;
    providerName(): string;
    refresh?(ctx: AuthContext): Promise<AuthContext>;
    revoke?(ctx: AuthContext): Promise<void>;
}

declare function base64UrlDecode(input: string): Uint8Array;

declare function base64UrlEncode(bytes: Uint8Array): string;

type BatchMode = "all_or_nothing" | "best_effort";

type Chain = "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "solana" | "bitcoin" | "cosmos" | "osmosis" | "aptos" | "sui" | "starknet";

declare const CHAIN_VALUES: readonly Chain[];

declare function chainCoinType(chain: Chain): number;

declare const ChainSchema: z.ZodEnum<[
    "ethereum",
    "polygon",
    "arbitrum",
    "optimism",
    "base",
    "solana",
    "bitcoin",
    "cosmos",
    "osmosis",
    "aptos",
    "sui",
    "starknet"
]>;

declare function concatBytes(...chunks: Uint8Array[]): Uint8Array;

interface CreateDidParams {
    entityKind: string;
    namespace: string;
    identifier: string;
    metadata: Record<string, string>;
}

declare function cryptoBackend(): CryptoBackend;

interface CryptoBackend {
    ed25519GenerateKeypair(): {
        signingKey: Uint8Array;
        verifyingKey: Uint8Array;
    };
    ed25519PublicFromPrivate(signingKey: Uint8Array): Uint8Array;
    ed25519Sign(signingKey: Uint8Array, message: Uint8Array): Uint8Array;
    ed25519Verify(verifyingKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
    hkdfSha256(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Uint8Array;
    blake3Hash(input: Uint8Array): Uint8Array;
    sha256(input: Uint8Array): Uint8Array;
    sha512(input: Uint8Array): Uint8Array;
    aes256GcmEncrypt(key: Uint8Array, nonce: Uint8Array, plaintext: Uint8Array): Uint8Array;
    aes256GcmDecrypt(key: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array): Uint8Array;
    jcsCanonicalize(value: unknown): Uint8Array;
    multibaseEncode(bytes: Uint8Array): string;
    multibaseDecode(encoded: string): Uint8Array;
    randomBytes(length: number): Uint8Array;
    frostTrustedKeygen(minSigners: number, maxSigners: number): {
        keyPackages: FrostKeyPackage[];
        publicKeyPackage: Uint8Array;
    };
    frostSignRound1(signingShare: Uint8Array): {
        nonces: Uint8Array;
        commitments: Uint8Array;
    };
    frostSignRound2(signingPackage: Uint8Array, nonces: Uint8Array, keyPackage: Uint8Array): Uint8Array;
    frostBuildSigningPackage(commitments: Map<number, Uint8Array>, message: Uint8Array): Uint8Array;
    frostAggregate(signingPackage: Uint8Array, signatureShares: Map<number, Uint8Array>, publicKeyPackage: Uint8Array): Uint8Array;
    frostVerify(publicKeyPackage: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
}

declare const DEFAULT_PAGE_SIZE = 100;

declare const DEFAULT_PAGINATION: Pagination;

declare const DEFAULT_VERIFICATION_CONFIG: VerificationConfig;

interface Delegation {
    id: string;
    delegator: string;
    delegate: string;
    scope: DelegationScope;
    created: string;
    expires?: string | null;
    revocable: boolean;
    proof: DelegationProof;
}

type DelegationError = {
    kind: "delegation/invalid_proof";
    reason: string;
    message: string;
} | {
    kind: "delegation/revoked";
    delegationId: string;
    message: string;
} | {
    kind: "delegation/expired";
    delegationId: string;
    message: string;
} | {
    kind: "delegation/max_depth_exceeded";
    depth: number;
    maxDepth: number;
    message: string;
} | {
    kind: "delegation/scope_amplification";
    reason: string;
    message: string;
} | {
    kind: "delegation/delegator_not_found";
    did: string;
    message: string;
} | {
    kind: "delegation/delegate_not_found";
    did: string;
    message: string;
};

declare const delegationErrors: {
    invalidProof: (reason: string) => DelegationError;
    revoked: (delegationId: string) => DelegationError;
    expired: (delegationId: string) => DelegationError;
    maxDepthExceeded: (depth: number, maxDepth: number) => DelegationError;
    scopeAmplification: (reason: string) => DelegationError;
    delegatorNotFound: (did: string) => DelegationError;
    delegateNotFound: (did: string) => DelegationError;
};

interface DelegationProof {
    type: "AegisDelegationProof2025";
    verificationMethod: string;
    created: string;
    jws: string;
}

declare const DelegationProofSchema: z.ZodObject<{
    type: z.ZodLiteral<"AegisDelegationProof2025">;
    verificationMethod: z.ZodString;
    created: z.ZodString;
    jws: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "AegisDelegationProof2025";
    verificationMethod: string;
    created: string;
    jws: string;
}, {
    type: "AegisDelegationProof2025";
    verificationMethod: string;
    created: string;
    jws: string;
}>;

declare const DelegationSchema: z.ZodObject<{
    id: z.ZodString;
    delegator: z.ZodString;
    delegate: z.ZodString;
    scope: z.ZodObject<{
        actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        chains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        limits: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            maxAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            dailyVolume: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            assetAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            recipientAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            approvalThreshold: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, "strip", z.ZodTypeAny, {
            assetAllowlist: string[];
            recipientAllowlist: string[];
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            approvalThreshold?: string | null | undefined;
        }, {
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            assetAllowlist?: string[] | undefined;
            recipientAllowlist?: string[] | undefined;
            approvalThreshold?: string | null | undefined;
        }>>>;
        temporal: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            activeHours: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                startHour: z.ZodNumber;
                endHour: z.ZodNumber;
                timezone: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                startHour: number;
                endHour: number;
                timezone: string;
            }, {
                startHour: number;
                endHour: number;
                timezone: string;
            }>>>;
            cooldown: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, "strip", z.ZodTypeAny, {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        }, {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        }>>>;
    }, "strip", z.ZodTypeAny, {
        actions: string[];
        resources: string[];
        chains: string[];
        limits?: {
            assetAllowlist: string[];
            recipientAllowlist: string[];
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    }, {
        actions?: string[] | undefined;
        resources?: string[] | undefined;
        chains?: string[] | undefined;
        limits?: {
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            assetAllowlist?: string[] | undefined;
            recipientAllowlist?: string[] | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    }>;
    created: z.ZodString;
    expires: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    revocable: z.ZodBoolean;
    proof: z.ZodObject<{
        type: z.ZodLiteral<"AegisDelegationProof2025">;
        verificationMethod: z.ZodString;
        created: z.ZodString;
        jws: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    }, {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    }>;
}, "strip", z.ZodTypeAny, {
    created: string;
    id: string;
    delegator: string;
    delegate: string;
    scope: {
        actions: string[];
        resources: string[];
        chains: string[];
        limits?: {
            assetAllowlist: string[];
            recipientAllowlist: string[];
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    };
    revocable: boolean;
    proof: {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    };
    expires?: string | null | undefined;
}, {
    created: string;
    id: string;
    delegator: string;
    delegate: string;
    scope: {
        actions?: string[] | undefined;
        resources?: string[] | undefined;
        chains?: string[] | undefined;
        limits?: {
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            assetAllowlist?: string[] | undefined;
            recipientAllowlist?: string[] | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    };
    revocable: boolean;
    proof: {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    };
    expires?: string | null | undefined;
}>;

interface DelegationScope {
    actions: string[];
    resources: string[];
    chains: string[];
    limits?: SpendingLimits | null;
    temporal?: TemporalConstraints | null;
}

declare const DelegationScopeSchema: z.ZodObject<{
    actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    chains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    limits: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        maxAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        dailyVolume: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        assetAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        recipientAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        approvalThreshold: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        assetAllowlist: string[];
        recipientAllowlist: string[];
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        approvalThreshold?: string | null | undefined;
    }, {
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        assetAllowlist?: string[] | undefined;
        recipientAllowlist?: string[] | undefined;
        approvalThreshold?: string | null | undefined;
    }>>>;
    temporal: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        activeHours: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            startHour: z.ZodNumber;
            endHour: z.ZodNumber;
            timezone: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            startHour: number;
            endHour: number;
            timezone: string;
        }, {
            startHour: number;
            endHour: number;
            timezone: string;
        }>>>;
        cooldown: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    }, {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    }>>>;
}, "strip", z.ZodTypeAny, {
    actions: string[];
    resources: string[];
    chains: string[];
    limits?: {
        assetAllowlist: string[];
        recipientAllowlist: string[];
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        approvalThreshold?: string | null | undefined;
    } | null | undefined;
    temporal?: {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    } | null | undefined;
}, {
    actions?: string[] | undefined;
    resources?: string[] | undefined;
    chains?: string[] | undefined;
    limits?: {
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        assetAllowlist?: string[] | undefined;
        recipientAllowlist?: string[] | undefined;
        approvalThreshold?: string | null | undefined;
    } | null | undefined;
    temporal?: {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    } | null | undefined;
}>;

declare function derivationStandard(chain: Chain): "BIP-44" | "SLIP-0010";

interface DidCreationResult {
    did: string;
    document: OasDocument;
}

interface DidResolver {
    resolve(did: string): Promise<OasDocument>;
    handles(did: string): boolean;
    supportedMethods(): readonly string[];
    create?(params: CreateDidParams): Promise<DidCreationResult>;
    update?(did: string, document: OasDocument): Promise<void>;
    deactivate?(did: string): Promise<void>;
}

interface DocumentMetadata {
    created: string;
    updated?: string | null;
}

interface DocumentProof {
    type: string;
    verificationMethod: string;
    created: string;
    jws?: string;
    proofValue?: string;
}

type EntityKind = "hmr" | "mhr" | "enr" | "ao" | "agent" | "agent:instance" | "tool" | "skill" | "workflow" | "model" | "dataset" | "service";

interface FrostKeyPackage {
    identifier: number;
    bytes: Uint8Array;
}

interface Guardian {
    guardianType: GuardianType;
    identifier: string;
    weight: number;
}

type GuardianType = "identity" | "email" | "phone" | "hardware";

declare function hexDecode(input: string): Uint8Array;

declare function hexEncode(bytes: Uint8Array): string;

type IdentityType = "human" | "agent" | "organization" | "enterprise" | "delegated";

declare const IdentityTypeSchema: z.ZodEnum<[
    "human",
    "agent",
    "organization",
    "enterprise",
    "delegated"
]>;

declare function inferIdentityTypeFromDid(did: string): "human" | "organization" | "enterprise" | "agent";

type KeyError = {
    kind: "key/generation_failed";
    reason: string;
    message: string;
} | {
    kind: "key/derivation_failed";
    reason: string;
    message: string;
} | {
    kind: "key/rotation_failed";
    reason: string;
    message: string;
} | {
    kind: "key/recovery_failed";
    reason: string;
    message: string;
} | {
    kind: "key/mpc_failed";
    reason: string;
    message: string;
} | {
    kind: "key/not_found";
    keyId: string;
    message: string;
} | {
    kind: "key/storage_error";
    reason: string;
    message: string;
} | {
    kind: "key/signing_failed";
    reason: string;
    message: string;
} | {
    kind: "key/unsupported_type";
    keyType: string;
    message: string;
};

declare const keyErrors: {
    generationFailed: (reason: string) => KeyError;
    derivationFailed: (reason: string) => KeyError;
    rotationFailed: (reason: string) => KeyError;
    recoveryFailed: (reason: string) => KeyError;
    mpcFailed: (reason: string) => KeyError;
    notFound: (keyId: string) => KeyError;
    storageError: (reason: string) => KeyError;
    signingFailed: (reason: string) => KeyError;
    unsupportedKeyType: (keyType: string) => KeyError;
};

type KeyGenerationMode = "direct" | "mpc" | "tee" | "hsm";

type KeyRole = "identity" | "authentication" | "assertion" | "delegation" | "session" | "recovery" | "chain";

declare const KeyRoleSchema: z.ZodEnum<[
    "identity",
    "authentication",
    "assertion",
    "delegation",
    "session",
    "recovery",
    "chain"
]>;

type LifecycleStatus = "active" | "suspended" | "terminated" | "deprecated" | "draft";

interface LineageSection {
    parent: string;
    generation: number;
    humanRootChain: string[];
    proof?: AgentLineageProof | null;
}

interface LineageSummary {
    depth: number;
    humanRoot: string;
    verified: boolean;
}

type LivenessStatus = "active" | "warning" | "stale" | "unknown";

declare function loadDefaultCryptoBackend(): Promise<void>;

declare function makePagination(limit: number, offset: number): Pagination;

declare const MAX_PAGE_SIZE = 1000;

declare const oasDocument: {
    isRoot(doc: OasDocument): boolean;
    isRevoked(doc: OasDocument): boolean;
    primaryPublicKeyMultibase(doc: OasDocument): string | null;
    findVerificationMethod(doc: OasDocument, id: string): VerificationMethod | null;
};

interface OasDocument {
    id: string;
    oasVersion: string;
    kind: string;
    verificationMethod: VerificationMethod[];
    authentication?: string[];
    assertionMethod?: string[];
    delegationMethod?: string[];
    metadata: DocumentMetadata;
    lineage?: LineageSection | null;
    lifecycleStatus?: LifecycleStatus | null;
    revoked?: boolean;
    proof?: DocumentProof | null;
    [key: string]: unknown;
}

interface Obligation {
    obligationType: ObligationType;
    params: Record<string, unknown>;
    deadline?: string | null;
}

type ObligationType = "log" | "notify" | "approve" | "escrow" | "limit";

interface Pagination {
    limit: number;
    offset: number;
}

interface PermissionCheck {
    principal: string;
    permission: string;
    resource?: string | null;
}

declare class PluginRegistry {
    registerResolver(resolver: DidResolver): void;
    registerAuthProvider(provider: AuthProvider): void;
    setPolicyEngine(engine: PolicyEngine): void;
    resolverCount(): number;
    authProviderCount(): number;
    hasPolicyEngine(): boolean;
    getResolverFor(did: string): DidResolver | null;
    getAuthProvider(name: string): AuthProvider | null;
    getPolicyEngine(): PolicyEngine | null;
    resolveDid(did: string): Promise<OasDocument>;
    validateCredential(credential: AuthCredential, providerName?: string | null): Promise<AuthContext>;
    evaluatePolicy(request: PolicyRequest): Promise<PolicyDecision>;
    checkPermission(check: PermissionCheck): Promise<boolean>;
}

interface PolicyContext {
    authContext?: AuthContext | null;
    lineage?: LineageSummary | null;
    conformanceLevel?: number | null;
    session?: Session | null;
    extra: Record<string, unknown>;
}

interface PolicyDecision {
    allowed: boolean;
    reason?: string | null;
    obligations: Obligation[];
    auditInfo: AuditInfo;
}

interface PolicyEngine {
    evaluate(request: PolicyRequest): Promise<PolicyDecision>;
    checkPermission(check: PermissionCheck): Promise<boolean>;
    engineName(): string;
    getPolicies?(did: string): Promise<unknown[]>;
}

type PolicyError = {
    kind: "policy/evaluation_failed";
    reason: string;
    message: string;
} | {
    kind: "policy/timeout";
    timeoutMs: number;
    message: string;
} | {
    kind: "policy/engine_unavailable";
    message: string;
} | {
    kind: "policy/no_engine";
    message: string;
} | {
    kind: "policy/config_error";
    reason: string;
    message: string;
};

declare const policyErrors: {
    evaluationFailed: (reason: string) => PolicyError;
    timeout: (timeoutMs: number) => PolicyError;
    engineUnavailable: () => PolicyError;
    noEngine: () => PolicyError;
    configError: (reason: string) => PolicyError;
};

interface PolicyRequest {
    principal: string;
    action: string;
    resource: string;
    context: PolicyContext;
}

interface RecoveryConfig {
    guardians: Guardian[];
    threshold: number;
    timelock: string;
}

type ResolverError = {
    kind: "resolver/not_found";
    did: string;
    message: string;
} | {
    kind: "resolver/invalid_format";
    reason: string;
    message: string;
} | {
    kind: "resolver/timeout";
    did: string;
    timeoutMs: number;
    message: string;
} | {
    kind: "resolver/deactivated";
    did: string;
    message: string;
} | {
    kind: "resolver/network";
    did: string;
    reason: string;
    message: string;
} | {
    kind: "resolver/creation_not_supported";
    message: string;
} | {
    kind: "resolver/update_not_supported";
    message: string;
} | {
    kind: "resolver/deactivation_not_supported";
    message: string;
};

declare const resolverErrors: {
    notFound: (did: string) => ResolverError;
    invalidFormat: (reason: string) => ResolverError;
    timeout: (did: string, timeoutMs: number) => ResolverError;
    deactivated: (did: string) => ResolverError;
    network: (did: string, reason: string) => ResolverError;
    creationNotSupported: () => ResolverError;
    updateNotSupported: () => ResolverError;
    deactivationNotSupported: () => ResolverError;
};

type RevocationStatus = "active" | "revoked" | "suspended" | "expired" | "unknown";

interface Session {
    sessionId: string;
    did: string;
    provider: string;
    createdAt: string;
    expiresAt: string;
    scope: string[];
    deviceBinding?: string | null;
}

interface SessionKey {
    sessionKey: string;
    principal: string;
    scope: DelegationScope;
    maxTransactions?: number | null;
    created: string;
    expires: string;
    proof: DelegationProof;
}

declare function setCryptoBackend(impl: CryptoBackend): void;

type SigningMode = "direct" | "mpc" | "tee" | "external";

interface SpendingLimits {
    maxAmount?: string | null;
    dailyVolume?: string | null;
    assetAllowlist: string[];
    recipientAllowlist: string[];
    approvalThreshold?: string | null;
}

declare const SpendingLimitsSchema: z.ZodObject<{
    maxAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    dailyVolume: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    assetAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    recipientAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    approvalThreshold: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    assetAllowlist: string[];
    recipientAllowlist: string[];
    maxAmount?: string | null | undefined;
    dailyVolume?: string | null | undefined;
    approvalThreshold?: string | null | undefined;
}, {
    maxAmount?: string | null | undefined;
    dailyVolume?: string | null | undefined;
    assetAllowlist?: string[] | undefined;
    recipientAllowlist?: string[] | undefined;
    approvalThreshold?: string | null | undefined;
}>;