@synet/credential/dist/credential.d.ts

VC Credentials - Simple, Robust, Unit-based Verifiable Credentials service

/**
 * @synet/credential - Unit-based W3C Verifiable Credential operations
 *
 * This unit provides W3C-compatible verifiable credential operations
 * using the learning pattern to acquire crypto capabilities from
 * other units (@synet/signer, @synet/keys, etc.)
 *
 * Key features:
 * - Learning-based architecture (no tight coupling)
 * - Progressive capability acquisition
 * - W3C-compatible credential formats using existing types
 * - Composable with crypto units
 * - Uses existing issueVC/verifyVC functions internally
 *
 * Usage pattern:
 * ```typescript
 * const signer = new Signer();
 * const credential = new Credential();
 *
 * // Learn crypto capabilities
 * credential.learn([signer.teach()]);
 *
 * // Issue credential
 * const vc = await credential.execute('issue', subject, type, issuer);
 * ```
 *
 * @author Synet Team
 */
import { Unit, type TeachingContract, type UnitProps } from "@synet/unit";
import { Result, type VerificationResult } from "./result";
import type { W3CVerifiableCredential, BaseCredentialSubject, CredentialIssueOptions, CredentialVerifyOptions, ProofType } from "./types-base";
export interface CredentialConfig {
    metadata?: Record<string, unknown>;
}
export interface CredentialProps extends UnitProps {
    created: Date;
    metadata: Record<string, unknown>;
}
export declare class Credential extends Unit<CredentialProps> {
    private constructor();
    static create(config?: CredentialConfig): Credential;
    whoami(): string;
    capabilities(): string[];
    help(): void;
    teach(): TeachingContract;
    /**
     * Issue a verifiable credential using Result pattern
     * Requires learned getPublicKey and sign capabilities from Key
     */
    issueCredential<S extends BaseCredentialSubject>(subject: S, type: string | string[], issuerDid: string, options?: CredentialIssueOptions): Promise<Result<W3CVerifiableCredential<S>>>;
    /**
     * Verify a verifiable credential using Result pattern
     *
     * Verifies a W3C verifiable credential using the learned capabilities.
     */
    verifyCredential(credential: W3CVerifiableCredential, options?: CredentialVerifyOptions): Promise<Result<VerificationResult>>;
    createCredentialPayload<S extends BaseCredentialSubject>(subject: S, type: string | string[], issuerDid: string, options?: CredentialIssueOptions): Omit<W3CVerifiableCredential<S>, "proof">;
    generateCredentialId(type: string): string;
    /**
     * Create a JWT proof for a credential
     * Follows JWT standard (RFC 7515) - uses base64url encoding for signature
     */
    createJWTProof(payload: Omit<W3CVerifiableCredential, "proof">, issuerDid?: string): Promise<Result<ProofType>>;
    /**
     * Verify a JWT proof using Result pattern
     * Converts base64url signature back to base64 for verification
     */
    verifyJWTProof(credential: W3CVerifiableCredential, options?: CredentialVerifyOptions): Promise<Result<VerificationResult>>;
    /**
     * Validate credential structure without cryptographic verification
     */
    validateStructure(credential: W3CVerifiableCredential): Promise<{
        valid: boolean;
        reason?: string;
    }>;
    /**
     * Check if this unit can perform a capability
     */
    can(capability: string): boolean;
    /**
     * Learn capabilities from other units (especially @synet/keys Key)
     */
    learn(contracts: TeachingContract[]): void;
}
export default Credential;