@ucanto/validator/dist/src/error.d.ts

UCAN RPC validators

export class EscalatedCapability extends Failure {
    /**
     * @param {API.ParsedCapability} claimed
     * @param {object} delegated
     * @param {API.Failure} cause
     */
    constructor(claimed: API.ParsedCapability, delegated: object, cause: API.Failure);
    claimed: API.ParsedCapability<API.Ability, API.URI, any>;
    delegated: object;
    cause: API.Failure;
    name: "EscalatedCapability";
}
/**
 * @implements {API.DelegationError}
 */
export class DelegationError extends Failure implements API.DelegationError {
    /**
     * @param {(API.InvalidCapability | API.EscalatedDelegation | API.DelegationError)[]} causes
     * @param {object} context
     */
    constructor(causes: (API.InvalidCapability | API.EscalatedDelegation | API.DelegationError)[], context: object);
    name: "InvalidClaim";
    causes: (API.DelegationError | API.InvalidCapability | API.EscalatedDelegation)[];
    context: object;
    /**
     * @type {API.InvalidCapability | API.EscalatedDelegation | API.DelegationError}
     */
    get cause(): API.DelegationError | API.InvalidCapability | API.EscalatedDelegation;
}
/**
 * @implements {API.SessionEscalation}
 */
export class SessionEscalation extends Failure implements API.SessionEscalation {
    /**
     * @param {object} source
     * @param {API.Delegation} source.delegation
     * @param {API.Failure} source.cause
     */
    constructor({ delegation, cause }: {
        delegation: API.Delegation;
        cause: API.Failure;
    });
    name: "SessionEscalation";
    delegation: API.Delegation<API.Capabilities>;
    cause: API.Failure;
}
/**
 * @implements {API.InvalidSignature}
 */
export class InvalidSignature extends Failure implements API.InvalidSignature {
    /**
     * @param {API.Delegation} delegation
     * @param {API.Verifier} verifier
     */
    constructor(delegation: API.Delegation, verifier: API.Verifier);
    name: "InvalidSignature";
    delegation: API.Delegation<API.Capabilities>;
    verifier: API.Verifier<`did:${string}:${string}`, API.SigAlg>;
    get issuer(): API.Principal<`did:${string}:${string}`>;
    get audience(): API.Principal<`did:${string}:${string}`>;
    get key(): `did:key:${string}`;
}
/**
 * @implements {API.UnavailableProof}
 */
export class UnavailableProof extends Failure implements API.UnavailableProof {
    /**
     * @param {API.UCAN.Link} link
     * @param {Error} [cause]
     */
    constructor(link: API.UCAN.Link, cause?: Error | undefined);
    name: "UnavailableProof";
    link: API.UCANLink<API.Capabilities, API.MulticodecCode<number, string>, API.SigAlg>;
    cause: Error | undefined;
}
export class DIDKeyResolutionError extends Failure {
    /**
     * @param {API.UCAN.DID} did
     * @param {API.Failure} [cause]
     */
    constructor(did: API.UCAN.DID, cause?: API.Failure | undefined);
    name: "DIDKeyResolutionError";
    did: `did:${string}:${string}`;
    cause: API.Failure | undefined;
}
/**
 * @implements {API.InvalidAudience}
 */
export class PrincipalAlignmentError extends Failure implements API.InvalidAudience {
    /**
     * @param {API.UCAN.Principal} audience
     * @param {API.Delegation} delegation
     */
    constructor(audience: API.UCAN.Principal, delegation: API.Delegation);
    name: "InvalidAudience";
    audience: API.Principal<`did:${string}:${string}`>;
    delegation: API.Delegation<API.Capabilities>;
    toJSON(): {
        name: "InvalidAudience";
        audience: `did:${string}:${string}`;
        delegation: {
            audience: `did:${string}:${string}`;
        };
        message: string;
        stack: string | undefined;
    };
}
/**
 * @implements {API.MalformedCapability}
 */
export class MalformedCapability extends Failure implements API.MalformedCapability {
    /**
     * @param {API.Capability} capability
     * @param {API.Failure} cause
     */
    constructor(capability: API.Capability, cause: API.Failure);
    name: "MalformedCapability";
    capability: API.Capability<API.Ability, `${string}:${string}`, any>;
    cause: API.Failure;
}
export class UnknownCapability extends Failure {
    /**
     * @param {API.Capability} capability
     */
    constructor(capability: API.Capability);
    name: "UnknownCapability";
    capability: API.Capability<API.Ability, `${string}:${string}`, any>;
}
export class Expired extends Failure {
    /**
     * @param {API.Delegation & { expiration: number }} delegation
     */
    constructor(delegation: API.Delegation & {
        expiration: number;
    });
    name: "Expired";
    delegation: API.Delegation<API.Capabilities> & {
        expiration: number;
    };
    get expiredAt(): number;
    toJSON(): {
        name: "Expired";
        message: string;
        expiredAt: number;
        stack: string | undefined;
    };
}
/**
 * @implements {API.Revoked}
 */
export class Revoked extends Failure implements API.Revoked {
    /**
     * @param {API.Delegation} delegation
     */
    constructor(delegation: API.Delegation);
    name: "Revoked";
    delegation: API.Delegation<API.Capabilities>;
    toJSON(): {
        name: "Revoked";
        message: string;
        stack: string | undefined;
    };
}
export class NotValidBefore extends Failure {
    /**
     * @param {API.Delegation & { notBefore: number }} delegation
     */
    constructor(delegation: API.Delegation & {
        notBefore: number;
    });
    name: "NotValidBefore";
    delegation: API.Delegation<API.Capabilities> & {
        notBefore: number;
    };
    get validAt(): number;
    toJSON(): {
        name: "NotValidBefore";
        message: string;
        validAt: number;
        stack: string | undefined;
    };
}
/**
 * @implements {API.Unauthorized}
 */
export class Unauthorized extends Failure implements API.Unauthorized {
    /**
     * @param {{
     * capability: API.CapabilityParser
     * delegationErrors: API.DelegationError[]
     * unknownCapabilities: API.Capability[]
     * invalidProofs: API.InvalidProof[]
     * failedProofs: API.InvalidClaim[]
     * }} cause
     */
    constructor({ capability, delegationErrors, unknownCapabilities, invalidProofs, failedProofs, }: {
        capability: API.CapabilityParser;
        delegationErrors: API.DelegationError[];
        unknownCapabilities: API.Capability[];
        invalidProofs: API.InvalidProof[];
        failedProofs: API.InvalidClaim[];
    });
    name: "Unauthorized";
    capability: API.CapabilityParser<API.Match<unknown, API.UnknownMatch>>;
    delegationErrors: API.DelegationError[];
    unknownCapabilities: API.Capability<API.Ability, `${string}:${string}`, any>[];
    invalidProofs: API.InvalidProof[];
    failedProofs: API.InvalidClaim[];
}
export function indent(message: string, indent?: string): string;
export function li(message: string): string;
import { Failure } from '@ucanto/core/result';
import { fail } from '@ucanto/core/result';
import * as API from '@ucanto/interface';
export { Failure, fail };
//# sourceMappingURL=error.d.ts.map