@extrimian/agent 0.12.0-2 → 0.12.0-4

package/dist/vc/models/waci-message.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WACIMessage = void 0;
+const did_core_1 = require("@extrimian/did-core");
+class WACIMessage extends did_core_1.DIDCommMessage {
+}
+exports.WACIMessage = WACIMessage;
+//# sourceMappingURL=waci-message.js.map

package/dist/vc/models/waci-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waci-message.js","sourceRoot":"","sources":["../../../src/vc/models/waci-message.ts"],"names":[],"mappings":";;;AAAA,kDAAqD;AAErD,MAAa,WAAY,SAAQ,yBAAc;CAC9C;AADD,kCACC"}

package/dist/vc/protocols/openid-protocol.d.ts

@@ -0,0 +1,161 @@
+import { IStorage } from '../../models/agent-storage';
+import { DID } from '../../models/did';
+import { CredentialFlow } from '../models/credentia-flow';
+import { VCProtocol } from './vc-protocol';
+export declare class OpenIDProtocol extends VCProtocol<any> {
+    private storage;
+    constructor(params?: {
+        issuer?: {};
+        hoder?: {};
+        verifier?: {};
+        storage: IStorage;
+    });
+    generateGUID(): string;
+    processMessage(message: any, context?: any, _did?: DID): Promise<any>;
+    isProtocolMessage(message: any): Promise<boolean>;
+    createInvitationMessage(flow: CredentialFlow, did: DID): Promise<any>;
+}
+export interface MicrosoftCredential {
+    jti: string;
+    iat: number;
+    response_type: string;
+    response_mode: string;
+    scope: string;
+    nonce: string;
+    client_id: string;
+    redirect_uri: string;
+    prompt: string;
+    state: string;
+    exp: number;
+    registration: Registration;
+    claims: Claims;
+    pin: Pin;
+    id_token_hint: string;
+}
+export interface Claims {
+    vp_token: VpToken;
+}
+export interface VpToken {
+    presentation_definition: PresentationDefinition;
+}
+export interface PresentationDefinition {
+    id: string;
+    input_descriptors: InputDescriptor[];
+}
+export interface InputDescriptor {
+    id: string;
+    schema: Schema[];
+    issuance: Issuance[];
+}
+export interface Issuance {
+    manifest: string;
+}
+export interface Schema {
+    uri: string;
+}
+export interface Pin {
+    length: number;
+    type: string;
+    alg: string;
+    iterations: number;
+    salt: string;
+    hash: string;
+}
+export interface Registration {
+    client_name: string;
+    subject_syntax_types_supported: string[];
+    vp_formats: VpFormats;
+}
+export interface VpFormats {
+    jwt_vp: JwtV;
+    jwt_vc: JwtV;
+}
+export interface JwtV {
+    alg: string[];
+}
+export interface MicrosoftCredentialInfo {
+    sub: string;
+    aud: string;
+    nonce: string;
+    sub_jwk: SubJwk;
+    did: string;
+    given_name: string;
+    family_name: string;
+    iss: string;
+    iat: number;
+    jti: string;
+    exp: number;
+    pin: Pin;
+}
+export interface Pin {
+    length: number;
+    type: string;
+    alg: string;
+    iterations: number;
+    salt: string;
+    hash: string;
+}
+export interface SubJwk {
+    crv: string;
+    kid: string;
+    kty: string;
+    x: string;
+    y: string;
+}
+export interface MicrosoftCredentialManifest {
+    id: string;
+    display: Display;
+    input: Input;
+    iss: string;
+    iat: number;
+}
+export interface Display {
+    locale: string;
+    contract: string;
+    card: Card;
+    consent: Consent;
+    claims: Claims;
+    id: string;
+}
+export interface Card {
+    title: string;
+    issuedBy: string;
+    backgroundColor: string;
+    textColor: string;
+    logo: Logo;
+    description: string;
+}
+export interface Logo {
+    uri: string;
+    description: string;
+}
+export interface Claims {
+    type: string;
+    label: string;
+}
+export interface VcCredentialSubject {
+    type: string;
+    label: string;
+}
+export interface Consent {
+    title: string;
+    instructions: string;
+}
+export interface Input {
+    credentialIssuer: string;
+    issuer: string;
+    attestations: Attestations;
+    id: string;
+}
+export interface Attestations {
+    accessTokens: AccessToken[];
+}
+export interface AccessToken {
+    id: string;
+    encrypted: boolean;
+    claims: any[];
+    required: boolean;
+    configuration: string;
+    resourceId: string;
+    oboScope: string;
+}

package/dist/vc/protocols/openid-protocol.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenIDProtocol = void 0;
+const axios_1 = __importDefault(require("axios"));
+const jwt_decode_1 = __importDefault(require("jwt-decode"));
+const utils_1 = require("../../utils");
+const vc_protocol_1 = require("./vc-protocol");
+class OpenIDProtocol extends vc_protocol_1.VCProtocol {
+    constructor(params) {
+        super();
+        this.storage = params.storage;
+    }
+    generateGUID() {
+        function generateSegment() {
+            return Math.floor((1 + Math.random()) * 0x10000)
+                .toString(16)
+                .substring(1);
+        }
+        return (generateSegment() +
+            generateSegment() +
+            '-' +
+            generateSegment() +
+            '-4' +
+            generateSegment().substr(0, 3) +
+            '-' +
+            generateSegment() +
+            '-' +
+            generateSegment() +
+            generateSegment() +
+            generateSegment());
+    }
+    async processMessage(message, context, _did) {
+        var _a;
+        const request_uri = (0, utils_1.getSearchParam)('request_uri', message);
+        const encodedData = (await axios_1.default.get(request_uri)).data;
+        const decodedData = (0, jwt_decode_1.default)(encodedData);
+        const credentialData = (0, jwt_decode_1.default)(decodedData.id_token_hint);
+        const manifestEncoded = (_a = (await axios_1.default.get(decodedData.claims.vp_token.presentation_definition.input_descriptors[0]
+            .issuance[0].manifest)).data) === null || _a === void 0 ? void 0 : _a.token;
+        const credentialManifest = (0, jwt_decode_1.default)(manifestEncoded);
+        const { did, sub, aud, exp, iat, iss, jti, nonce, sub_jwk, pin, ...rest } = credentialData;
+        const data = {
+            credentialSubject: {
+                ...rest,
+            },
+            id: this.generateGUID(),
+            type: [
+                decodedData.claims.vp_token.presentation_definition.input_descriptors[0]
+                    .id,
+            ],
+            issuer: {
+                id: credentialData.iss,
+                name: credentialManifest.display.card.issuedBy,
+            },
+            issuanceDate: new Date(),
+        };
+        const claims = [
+            {
+                path: '$.credentialSubject.given_name',
+                label: 'First Name',
+            },
+            {
+                path: '$.credentialSubject.family_name',
+                label: 'Last Name',
+            },
+        ];
+        const display = {
+            description: {
+                text: credentialManifest.display.card.description,
+            },
+            title: {
+                text: credentialManifest.display.card.title,
+            },
+            properties: claims.map((claim) => {
+                const value = {
+                    label: claim.label,
+                    path: [claim.path],
+                    schema: {
+                        type: 'string',
+                    },
+                    fallback: 'Unknown',
+                };
+                return value;
+            }),
+        };
+        const styles = {
+            thumbnail: {
+                alt: credentialManifest.display.card.logo.description,
+                uri: credentialManifest.display.card.logo.uri,
+            },
+            background: { color: credentialManifest.display.card.backgroundColor },
+            text: {
+                color: credentialManifest.display.card.textColor,
+            },
+            hero: {
+                uri: '',
+                alt: '',
+            },
+        };
+        const issuer = {
+            id: credentialData.iss,
+            name: credentialManifest.display.card.issuedBy,
+        };
+        this.onVcArrived.trigger({
+            credentials: [{ data, styles, display }],
+            messageId: "",
+            issuer,
+        });
+    }
+    async isProtocolMessage(message) {
+        if (typeof message === 'string' &&
+            message.includes('openid-vc://') &&
+            (0, utils_1.getSearchParam)('request_uri', message)) {
+            return true;
+        }
+        return false;
+    }
+    async createInvitationMessage(flow, did) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.OpenIDProtocol = OpenIDProtocol;
+//# sourceMappingURL=openid-protocol.js.map

package/dist/vc/protocols/openid-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openid-protocol.js","sourceRoot":"","sources":["../../../src/vc/protocols/openid-protocol.ts"],"names":[],"mappings":"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"}

package/dist/vc/protocols/vc-protocol.d.ts

@@ -0,0 +1,106 @@
+import { VerifiableCredential } from "@extrimian/vc-core";
+import { Agent } from "../../agent";
+import { DID } from "../../models/did";
+import { LiteEvent } from "../../utils/lite-event";
+import { CredentialFlow } from "../models/credentia-flow";
+import { IssuerData, VerifiableCredentialWithInfo } from "./waci-protocol";
+export declare enum ActorRole {
+    Issuer = 0,
+    Holder = 1,
+    Verifier = 2
+}
+export declare abstract class VCProtocol<TProtocolMessage = any> {
+    protected readonly onVcArrived: LiteEvent<{
+        credentials: VerifiableCredentialWithInfo[];
+        issuer: IssuerData;
+        messageId: string;
+    }>;
+    get vcArrived(): import("../../utils/lite-event").ILiteEvent<{
+        credentials: VerifiableCredentialWithInfo[];
+        issuer: IssuerData;
+        messageId: string;
+    }>;
+    protected readonly onCredentialIssued: LiteEvent<{
+        vc: VerifiableCredential;
+        toDID: DID;
+        invitationId?: string;
+    }>;
+    get credentialIssued(): import("../../utils/lite-event").ILiteEvent<{
+        vc: VerifiableCredential<any>;
+        toDID: DID;
+        invitationId?: string;
+    }>;
+    protected readonly onVcVerified: LiteEvent<{
+        verified: boolean;
+        presentationVerified: boolean;
+        vc: VerifiableCredential;
+    }>;
+    get vcVerified(): import("../../utils/lite-event").ILiteEvent<{
+        verified: boolean;
+        presentationVerified: boolean;
+        vc: VerifiableCredential<any>;
+    }>;
+    protected readonly onPresentationVerified: LiteEvent<{
+        verified: boolean;
+        vcs: VerifiableCredential[];
+        thid: string;
+        invitationId: string;
+        rejectMsg?: string;
+        messageId: string;
+    }>;
+    get presentationVerified(): import("../../utils/lite-event").ILiteEvent<{
+        verified: boolean;
+        vcs: VerifiableCredential<any>[];
+        thid: string;
+        invitationId: string;
+        rejectMsg?: string;
+        messageId: string;
+    }>;
+    protected readonly onAckCompleted: LiteEvent<{
+        role: ActorRole;
+        status: string;
+        messageId: string;
+        thid: string;
+        invitationId?: string;
+    }>;
+    get ackCompleted(): import("../../utils/lite-event").ILiteEvent<{
+        role: ActorRole;
+        status: string;
+        messageId: string;
+        thid: string;
+        invitationId?: string;
+    }>;
+    protected readonly onProblemReport: LiteEvent<{
+        did: DID;
+        code: string;
+        codeMessage: string;
+        invitationId: string;
+        messageId: string;
+    }>;
+    get problemReport(): import("../../utils/lite-event").ILiteEvent<{
+        did: DID;
+        code: string;
+        codeMessage: string;
+        invitationId: string;
+        messageId: string;
+    }>;
+    abstract processMessage(message: TProtocolMessage, context?: any, did?: DID): Promise<VCProtocolResponse | void>;
+    abstract isProtocolMessage(message: any): Promise<boolean>;
+    abstract createInvitationMessage(flow: CredentialFlow, did: DID): Promise<TProtocolMessage>;
+    protected agent: Agent;
+    constructor();
+    initialize(params: {
+        agent: Agent;
+    }): void;
+}
+export declare enum VCMessageType {
+    RequestCredential = 0
+}
+export interface CredentialRequestedEventArg<TProtocolMessage = any> {
+    did: string;
+    protocolMessage: TProtocolMessage;
+}
+export interface VCProtocolResponse {
+    to: DID;
+    message: any;
+}

package/dist/vc/protocols/vc-protocol.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VCMessageType = exports.VCProtocol = exports.ActorRole = void 0;
+const lite_event_1 = require("../../utils/lite-event");
+var ActorRole;
+(function (ActorRole) {
+    ActorRole[ActorRole["Issuer"] = 0] = "Issuer";
+    ActorRole[ActorRole["Holder"] = 1] = "Holder";
+    ActorRole[ActorRole["Verifier"] = 2] = "Verifier";
+})(ActorRole = exports.ActorRole || (exports.ActorRole = {}));
+class VCProtocol {
+    get vcArrived() { return this.onVcArrived.expose(); }
+    get credentialIssued() { return this.onCredentialIssued.expose(); }
+    get vcVerified() { return this.onVcVerified.expose(); }
+    get presentationVerified() { return this.onPresentationVerified.expose(); }
+    get ackCompleted() { return this.onAckCompleted.expose(); }
+    get problemReport() { return this.onProblemReport.expose(); }
+    constructor() {
+        // protected readonly onCredentialRequested = new LiteEvent<CredentialRequestedEventArg>;
+        // public get credentialRequested() { return this.onCredentialRequested.expose(); }
+        this.onVcArrived = new lite_event_1.LiteEvent;
+        this.onCredentialIssued = new lite_event_1.LiteEvent;
+        this.onVcVerified = new lite_event_1.LiteEvent;
+        this.onPresentationVerified = new lite_event_1.LiteEvent;
+        this.onAckCompleted = new lite_event_1.LiteEvent;
+        this.onProblemReport = new lite_event_1.LiteEvent;
+    }
+    initialize(params) {
+        this.agent = params.agent;
+    }
+}
+exports.VCProtocol = VCProtocol;
+var VCMessageType;
+(function (VCMessageType) {
+    VCMessageType[VCMessageType["RequestCredential"] = 0] = "RequestCredential";
+})(VCMessageType = exports.VCMessageType || (exports.VCMessageType = {}));
+//# sourceMappingURL=vc-protocol.js.map

package/dist/vc/protocols/vc-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vc-protocol.js","sourceRoot":"","sources":["../../../src/vc/protocols/vc-protocol.ts"],"names":[],"mappings":";;;AAKA,uDAAmD;AAInD,IAAY,SAIX;AAJD,WAAY,SAAS;IACjB,6CAAM,CAAA;IACN,6CAAM,CAAA;IACN,iDAAQ,CAAA;AACZ,CAAC,EAJW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAIpB;AAED,MAAsB,UAAU;IAK5B,IAAW,SAAS,KAAK,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAG5D,IAAW,gBAAgB,KAAK,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAG1E,IAAW,UAAU,KAAK,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAG9D,IAAW,oBAAoB,KAAK,OAAO,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAGlF,IAAW,YAAY,KAAK,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAGlE,IAAW,aAAa,KAAK,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IASpE;QA5BA,yFAAyF;QACzF,mFAAmF;QAEhE,gBAAW,GAAG,IAAI,sBAAiG,CAAC;QAGpH,uBAAkB,GAAG,IAAI,sBAA0E,CAAC;QAGpG,iBAAY,GAAG,IAAI,sBAAyF,CAAC;QAG7G,2BAAsB,GAAG,IAAI,sBAAwI,CAAC;QAGtK,mBAAc,GAAG,IAAI,sBAAsG,CAAC;QAG5H,oBAAe,GAAG,IAAI,sBAAmG,CAAC;IAY7I,CAAC;IAED,UAAU,CAAC,MAEV;QACG,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC9B,CAAC;CACJ;AAtCD,gCAsCC;AAED,IAAY,aAEX;AAFD,WAAY,aAAa;IACrB,2EAAiB,CAAA;AACrB,CAAC,EAFW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAExB"}

package/dist/vc/protocols/waci-protocol.d.ts

@@ -0,0 +1,183 @@
+import { Issuer, UnsignedCredential, VerifiableCredential } from "@extrimian/vc-core";
+import { ClaimFormat, CredentialManifestStyles, DisplayMappingObject, GoalCode, InputDescriptor, OutputDescriptor, PresentationDefinition, PresentationDefinitionFrame, WACIMessage } from "@extrimian/waci";
+import { Agent } from "../../agent";
+import { IStorage } from "../../models/agent-storage";
+import { DID } from "../../models/did";
+import { CredentialFlow } from "../models/credentia-flow";
+import { VCProtocol, VCProtocolResponse } from "./vc-protocol";
+export declare class WACIProtocol extends VCProtocol<WACIMessage> {
+    private waciInterpreter;
+    private storage;
+    issueCredentials: (waciInvitationId: string, holderDID: string) => Promise<WACICredentialOfferResponse>;
+    issuerVerificationRules?: (waciInvitationId: string, holdedDID: string) => Promise<IssuerVerificationRuleResult>;
+    selectVcToPresent?: (vcs: VerifiableCredential[]) => Promise<VerifiableCredential[]>;
+    presentationDefinition?: (invitationId: string) => Promise<{
+        inputDescriptors: InputDescriptor[];
+        frame?: PresentationDefinitionFrame;
+    }>;
+    credentialApplication?: (inputs: {
+        descriptor: InputDescriptor;
+        credentials: VerifiableCredentialWithInfo[];
+    }[], selectiveDisclosure?: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: VerifiableCredentialWithInfo[]) => Promise<VerifiableCredential[]>;
+    credentialApplicationAsync: (inputs: {
+        descriptor: InputDescriptor;
+        credentials: VerifiableCredentialWithInfo[];
+    }[], invitationId: string, selectiveDisclosure?: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: VerifiableCredentialWithInfo[]) => Promise<void>;
+    businessVerificationRules?: (invitationId: string, holderDID: DID, vcs: VerifiableCredential[]) => Promise<BusinessRulesVerificationResult>;
+    constructor(params?: {
+        issuer?: {
+            issueCredentials?: (waciInvitationId: string, holderDID: string) => Promise<WACICredentialOfferResponse>;
+            issuerVerificationRules?: (waciInvitationId: string, holdedDID: string) => Promise<IssuerVerificationRuleResult>;
+        };
+        holder?: {
+            selectVcToPresent?: (vcs: VerifiableCredential[]) => Promise<VerifiableCredential[]>;
+            credentialApplication?: (inputs: {
+                descriptor: InputDescriptor;
+                credentials: VerifiableCredentialWithInfo[];
+            }[], selectiveDisclosure: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: {
+                data: VerifiableCredential;
+                styles: CredentialManifestStyles;
+                display: CredentialDisplay;
+            }[]) => Promise<VerifiableCredential[]>;
+            credentialApplicationAsync?: (inputs: {
+                descriptor: InputDescriptor;
+                credentials: VerifiableCredentialWithInfo[];
+            }[], invitationId: string, selectiveDisclosure: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: {
+                data: VerifiableCredential;
+                styles: CredentialManifestStyles;
+                display: CredentialDisplay;
+            }[]) => Promise<void>;
+        };
+        verifier?: {
+            presentationDefinition?: (invitationId: string) => Promise<{
+                inputDescriptors: InputDescriptor[];
+                frame?: PresentationDefinitionFrame;
+            }>;
+            businessVerificationRules?: (invitationId: string, holderDID: DID, vcs: VerifiableCredential[]) => Promise<BusinessRulesVerificationResult>;
+        };
+        storage: IStorage;
+    });
+    initialize(params: {
+        agent: Agent;
+    }): void;
+    presentationProceed(invitationId: string, credentialsToPresent: VerifiableCredential[]): Promise<{
+        to: DID;
+        from: DID;
+        message: import("@extrimian/kms-core").DIDCommPackedMessage;
+    }>;
+    processMessage(message: WACIMessage | string, context?: any, did?: DID): Promise<VCProtocolResponse | void>;
+    createOBBInvitation(goalCode: GoalCode, did: DID): Promise<WACIMessage>;
+    createInvitationMessage(flow: CredentialFlow, did: DID): Promise<WACIMessage>;
+    isProtocolMessage(message: any): Promise<boolean>;
+    private decodeMessage;
+    private validateSchema;
+}
+export declare enum WACIRequest {
+    CredentialManifestRequested = 0
+}
+export declare enum InternalStorageEnum {
+    CredentialManifests = "CredentialManifests"
+}
+export type VerifiableCredentialWithInfo = {
+    data: VerifiableCredential;
+    styles?: CredentialManifestStyles;
+    display?: CredentialDisplay;
+};
+export declare class SelectiveDisclosure {
+    allFieldsToReveal: string[];
+    credentialSubjectFieldsToReveal: string[];
+    constructor();
+    static from(frame: any, outputDescriptors: any[]): SelectiveDisclosure;
+}
+export type SelectiveDisclosureField = {
+    id: string;
+};
+export type CredentialManifestData = {
+    id: string;
+    version: string;
+    issuer: IssuerData;
+    format?: ClaimFormat;
+    output_descriptors: OutputDescriptor[];
+    presentation_definition?: PresentationDefinition;
+};
+export type IssuerData = {
+    id: string;
+    name: string;
+    styles?: CredentialManifestStyles;
+};
+export type CredentialDisplay = {
+    title?: DisplayMappingObject;
+    subtitle?: DisplayMappingObject;
+    description?: DisplayMappingObject;
+    properties?: (DisplayMappingObject & {
+        label?: string;
+    })[];
+};
+export declare class WACIEventArg {
+    request: WACIRequest;
+}
+export declare class CredentialRequestedEventArg extends WACIEventArg {
+    waciInvitationId: string;
+    fromDid: string;
+}
+export type IssuerVerificationRuleResult = {
+    verified: boolean;
+    rejectMsg: string;
+};
+export type BusinessRulesVerificationResult = {
+    result: true;
+} | {
+    result: false;
+    rejectMessage: string;
+};
+export type WACICredentialOfferResponse = WACICredentialOfferWaitForResponse | WACICredentialOfferRejected | WACICredentialOfferSucceded;
+export declare enum WACICredentialOfferResult {
+    Succeded = 0,
+    Failed = 1,
+    AsyncProcess = 2
+}
+export declare enum CredentialApplicationResponse {
+    AsyncProcess = 0
+}
+export interface WACICredentialOfferWaitForResponse {
+    result: WACICredentialOfferResult.AsyncProcess;
+}
+export declare class WACICredentialOfferRejected {
+    result: WACICredentialOfferResult.Failed;
+    rejectMsg: string;
+}
+export declare class WACICredentialOfferSucceded {
+    result: WACICredentialOfferResult.Succeded;
+    credentialManifest: {
+        options?: {
+            challenge: string;
+            domain: string;
+        };
+        issuer: {
+            name: string;
+            styles: CredentialManifestStyles;
+        };
+        credentials: {
+            credential: UnsignedCredential;
+            outputDescriptor: OutputDescriptor;
+        }[];
+        inputDescriptors?: InputDescriptor[];
+        frame?: PresentationDefinitionFrame;
+    };
+    constructor(credentialManifest: {
+        options?: {
+            challenge: string;
+            domain: string;
+        };
+        issuer: {
+            name: string;
+            styles: CredentialManifestStyles;
+        };
+        credentials: {
+            credential: UnsignedCredential;
+            outputDescriptor: OutputDescriptor;
+        }[];
+        inputDescriptors?: InputDescriptor[];
+        frame?: PresentationDefinitionFrame;
+    });
+}