@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/modules/vc/W3cCredentialService.d.mts

@@ -0,0 +1,71 @@
+import { Query, QueryOptions } from "../../storage/StorageService.mjs";
+import { ClaimFormat } from "./models/ClaimFormat.mjs";
+import { W3cCredentialRecord } from "./repository/W3cCredentialRecord.mjs";
+import { W3cCredentialRepository } from "./repository/W3cCredentialRepository.mjs";
+import "./repository/index.mjs";
+import { W3cVerifiableCredential } from "./models/credential/W3cVerifiableCredential.mjs";
+import { W3cPresentation } from "./models/presentation/W3cPresentation.mjs";
+import { W3cVerifiablePresentation } from "./models/presentation/W3cVerifiablePresentation.mjs";
+import { W3cVerifyCredentialResult, W3cVerifyPresentationResult } from "./models/W3cVerifyResult.mjs";
+import "./models/index.mjs";
+import { W3cCreatePresentationOptions, W3cSignCredentialOptions, W3cSignPresentationOptions, W3cStoreCredentialOptions, W3cVerifyCredentialOptions, W3cVerifyPresentationOptions } from "./W3cCredentialServiceOptions.mjs";
+import { W3cJwtCredentialService } from "./jwt-vc/W3cJwtCredentialService.mjs";
+import { W3cJsonLdCredentialService } from "./data-integrity/W3cJsonLdCredentialService.mjs";
+import { AgentContext } from "../../agent/context/AgentContext.mjs";
+import "../../agent/context/index.mjs";
+
+//#region src/modules/vc/W3cCredentialService.d.ts
+declare class W3cCredentialService {
+  private w3cCredentialRepository;
+  private w3cJsonLdCredentialService;
+  private w3cJwtCredentialService;
+  constructor(w3cCredentialRepository: W3cCredentialRepository, w3cJsonLdCredentialService: W3cJsonLdCredentialService, w3cJwtCredentialService: W3cJwtCredentialService);
+  /**
+   * Signs a credential
+   *
+   * @param credential the credential to be signed
+   * @returns the signed credential
+   */
+  signCredential<Format extends ClaimFormat.JwtVc | ClaimFormat.LdpVc>(agentContext: AgentContext, options: W3cSignCredentialOptions<Format>): Promise<W3cVerifiableCredential<Format>>;
+  /**
+   * Verifies the signature(s) of a credential
+   */
+  verifyCredential(agentContext: AgentContext, options: W3cVerifyCredentialOptions): Promise<W3cVerifyCredentialResult>;
+  /**
+   * Utility method that creates a {@link W3cPresentation} from one or more {@link W3cJsonLdVerifiableCredential}s.
+   *
+   * **NOTE: the presentation that is returned is unsigned.**
+   *
+   * @returns An instance of {@link W3cPresentation}
+   */
+  createPresentation(options: W3cCreatePresentationOptions): Promise<W3cPresentation>;
+  /**
+   * Signs a presentation including the credentials it includes
+   *
+   * @param presentation the presentation to be signed
+   * @returns the signed presentation
+   */
+  signPresentation<Format extends ClaimFormat.JwtVp | ClaimFormat.LdpVp>(agentContext: AgentContext, options: W3cSignPresentationOptions<Format>): Promise<W3cVerifiablePresentation<Format>>;
+  /**
+   * Verifies a presentation including the credentials it includes
+   *
+   * @param presentation the presentation to be verified
+   * @returns the verification result
+   */
+  verifyPresentation(agentContext: AgentContext, options: W3cVerifyPresentationOptions): Promise<W3cVerifyPresentationResult>;
+  /**
+   * Writes a credential to storage
+   *
+   * @param record the credential to be stored
+   * @returns the credential record that was written to storage
+   */
+  storeCredential(agentContext: AgentContext, options: W3cStoreCredentialOptions): Promise<W3cCredentialRecord>;
+  removeCredentialRecord(agentContext: AgentContext, id: string): Promise<void>;
+  getAllCredentialRecords(agentContext: AgentContext): Promise<W3cCredentialRecord[]>;
+  getCredentialRecordById(agentContext: AgentContext, id: string): Promise<W3cCredentialRecord>;
+  findCredentialsByQuery(agentContext: AgentContext, query: Query<W3cCredentialRecord>, queryOptions?: QueryOptions): Promise<W3cVerifiableCredential[]>;
+  findCredentialRecordByQuery(agentContext: AgentContext, query: Query<W3cCredentialRecord>): Promise<W3cVerifiableCredential | undefined>;
+}
+//#endregion
+export { W3cCredentialService };
+//# sourceMappingURL=W3cCredentialService.d.mts.map

package/build/modules/vc/W3cCredentialService.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialService.d.mts","names":[],"sources":["../../../src/modules/vc/W3cCredentialService.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;cAiCa,oBAAA;;;;uCAMgB,qDACG,qDACH;;;;;;AAT7B;EAO6B,cAAA,CAAA,eAegB,WAAA,CAAY,KAf5B,GAeoC,WAAA,CAAY,KAfhD,CAAA,CAAA,YAAA,EAgBX,YAhBW,EAAA,OAAA,EAiBhB,wBAjBgB,CAiBS,MAjBT,CAAA,CAAA,EAkBxB,OAlBwB,CAkBhB,uBAlBgB,CAkBQ,MAlBR,CAAA,CAAA;EACG;;;EAciC,gBAAY,CAAA,YAAA,EAmB3D,YAnB2D,EAAA,OAAA,EAoBhE,0BApBgE,CAAA,EAqBxE,OArBwE,CAqBhE,yBArBgE,CAAA;EAC3D;;;;;;;EAmBL,kBAAA,CAAA,OAAA,EAoB8B,4BApB9B,CAAA,EAoB6D,OApB7D,CAoBqE,eApBrE,CAAA;EACA;;;;;;EAqCsD,gBAAY,CAAA,eAAhC,WAAA,CAAY,KAAoB,GAAZ,WAAA,CAAY,KAAA,CAAA,CAAA,YAAA,EAC7D,YAD6D,EAAA,OAAA,EAElE,0BAFkE,CAEvC,MAFuC,CAAA,CAAA,EAG1E,OAH0E,CAGlE,yBAHkE,CAGxC,MAHwC,CAAA,CAAA;EAC7D;;;;;;EAqBA,kBAAA,CAAA,YAAA,EAAA,YAAA,EAAA,OAAA,EACL,4BADK,CAAA,EAEb,OAFa,CAEL,2BAFK,CAAA;EACL;;;;;;EAyBR,eAAA,CAAA,YAAA,EAFa,YAEb,EAAA,OAAA,EADQ,yBACR,CAAA,EAAA,OAAA,CAAQ,mBAAR,CAAA;EAiB+C,sBAAA,CAAA,YAAA,EAAA,YAAA,EAAA,EAAA,EAAA,MAAA,CAAA,EAAwB,OAAxB,CAAA,IAAA,CAAA;EAAwB,uBAAA,CAAA,YAAA,EAIvB,YAJuB,CAAA,EAIR,OAJQ,CAIA,mBAJA,EAAA,CAAA;EAIvB,uBAAA,CAAA,YAAA,EAIA,YAJA,EAAA,EAAA,EAAA,MAAA,CAAA,EAI2B,OAJ3B,CAImC,mBAJnC,CAAA;EAAuB,sBAAA,CAAA,YAAA,EAS1D,YAT0D,EAAA,KAAA,EAUjE,KAViE,CAU3D,mBAV2D,CAAA,EAAA,YAAA,CAAA,EAWzD,YAXyD,CAAA,EAYvE,OAZuE,CAY/D,uBAZ+D,EAAA,CAAA;EAAR,2BAAA,CAAA,YAAA,EAkBlD,YAlBkD,EAAA,KAAA,EAmBzD,KAnByD,CAmBnD,mBAnBmD,CAAA,CAAA,EAoB/D,OApB+D,CAoBvD,uBApBuD,GAAA,SAAA,CAAA"}

package/build/modules/vc/W3cCredentialService.mjs

@@ -0,0 +1,124 @@
+
+
+import { CredoError } from "../../error/CredoError.mjs";
+import "../../error/index.mjs";
+import { injectable } from "../../plugins/index.mjs";
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { CREDENTIALS_CONTEXT_V1_URL } from "./constants.mjs";
+import { ClaimFormat } from "./models/ClaimFormat.mjs";
+import { W3cJsonLdVerifiableCredential } from "./data-integrity/models/W3cJsonLdVerifiableCredential.mjs";
+import { W3cJwtVerifiableCredential } from "./jwt-vc/W3cJwtVerifiableCredential.mjs";
+import { W3cPresentation } from "./models/presentation/W3cPresentation.mjs";
+import { W3cJwtVerifiablePresentation } from "./jwt-vc/W3cJwtVerifiablePresentation.mjs";
+import { W3cJwtCredentialService } from "./jwt-vc/W3cJwtCredentialService.mjs";
+import "./jwt-vc/index.mjs";
+import "./models/index.mjs";
+import { W3cJsonLdVerifiablePresentation } from "./data-integrity/models/W3cJsonLdVerifiablePresentation.mjs";
+import { W3cJsonLdCredentialService } from "./data-integrity/W3cJsonLdCredentialService.mjs";
+import "./data-integrity/index.mjs";
+import { W3cCredentialRepository } from "./repository/W3cCredentialRepository.mjs";
+import "./repository/index.mjs";
+
+//#region src/modules/vc/W3cCredentialService.ts
+var _ref, _ref2, _ref3;
+let W3cCredentialService = class W3cCredentialService$1 {
+	constructor(w3cCredentialRepository, w3cJsonLdCredentialService, w3cJwtCredentialService) {
+		this.w3cCredentialRepository = w3cCredentialRepository;
+		this.w3cJsonLdCredentialService = w3cJsonLdCredentialService;
+		this.w3cJwtCredentialService = w3cJwtCredentialService;
+	}
+	/**
+	* Signs a credential
+	*
+	* @param credential the credential to be signed
+	* @returns the signed credential
+	*/
+	async signCredential(agentContext, options) {
+		if (options.format === ClaimFormat.JwtVc) return await this.w3cJwtCredentialService.signCredential(agentContext, options);
+		if (options.format === ClaimFormat.LdpVc) return await this.w3cJsonLdCredentialService.signCredential(agentContext, options);
+		throw new CredoError(`Unsupported format in options. Format must be either 'jwt_vc' or 'ldp_vc'`);
+	}
+	/**
+	* Verifies the signature(s) of a credential
+	*/
+	async verifyCredential(agentContext, options) {
+		if (options.credential instanceof W3cJsonLdVerifiableCredential) return this.w3cJsonLdCredentialService.verifyCredential(agentContext, options);
+		if (options.credential instanceof W3cJwtVerifiableCredential || typeof options.credential === "string") return this.w3cJwtCredentialService.verifyCredential(agentContext, options);
+		throw new CredoError("Unsupported credential type in options. Credential must be either a W3cJsonLdVerifiableCredential or a W3cJwtVerifiableCredential");
+	}
+	/**
+	* Utility method that creates a {@link W3cPresentation} from one or more {@link W3cJsonLdVerifiableCredential}s.
+	*
+	* **NOTE: the presentation that is returned is unsigned.**
+	*
+	* @returns An instance of {@link W3cPresentation}
+	*/
+	async createPresentation(options) {
+		return new W3cPresentation({
+			context: [CREDENTIALS_CONTEXT_V1_URL],
+			type: ["VerifiablePresentation"],
+			verifiableCredential: options.credentials,
+			holder: options.holder,
+			id: options.id
+		});
+	}
+	/**
+	* Signs a presentation including the credentials it includes
+	*
+	* @param presentation the presentation to be signed
+	* @returns the signed presentation
+	*/
+	async signPresentation(agentContext, options) {
+		if (options.format === ClaimFormat.JwtVp) return await this.w3cJwtCredentialService.signPresentation(agentContext, options);
+		if (options.format === ClaimFormat.LdpVp) return await this.w3cJsonLdCredentialService.signPresentation(agentContext, options);
+		throw new CredoError(`Unsupported format in options. Format must be either 'jwt_vp' or 'ldp_vp'`);
+	}
+	/**
+	* Verifies a presentation including the credentials it includes
+	*
+	* @param presentation the presentation to be verified
+	* @returns the verification result
+	*/
+	async verifyPresentation(agentContext, options) {
+		if (options.presentation instanceof W3cJsonLdVerifiablePresentation) return this.w3cJsonLdCredentialService.verifyPresentation(agentContext, options);
+		if (options.presentation instanceof W3cJwtVerifiablePresentation || typeof options.presentation === "string") return this.w3cJwtCredentialService.verifyPresentation(agentContext, options);
+		throw new CredoError("Unsupported credential type in options. Presentation must be either a W3cJsonLdVerifiablePresentation or a W3cJwtVerifiablePresentation");
+	}
+	/**
+	* Writes a credential to storage
+	*
+	* @param record the credential to be stored
+	* @returns the credential record that was written to storage
+	*/
+	async storeCredential(agentContext, options) {
+		const credential = options.record.firstCredential;
+		if (credential instanceof W3cJsonLdVerifiableCredential && !options.record.getTag("expandedTypes")) options.record.setTag("expandedTypes", await this.w3cJsonLdCredentialService.getExpandedTypesForCredential(agentContext, credential));
+		await this.w3cCredentialRepository.save(agentContext, options.record);
+		return options.record;
+	}
+	async removeCredentialRecord(agentContext, id) {
+		await this.w3cCredentialRepository.deleteById(agentContext, id);
+	}
+	async getAllCredentialRecords(agentContext) {
+		return await this.w3cCredentialRepository.getAll(agentContext);
+	}
+	async getCredentialRecordById(agentContext, id) {
+		return await this.w3cCredentialRepository.getById(agentContext, id);
+	}
+	async findCredentialsByQuery(agentContext, query, queryOptions) {
+		return (await this.w3cCredentialRepository.findByQuery(agentContext, query, queryOptions)).map((record) => record.firstCredential);
+	}
+	async findCredentialRecordByQuery(agentContext, query) {
+		return (await this.w3cCredentialRepository.findSingleByQuery(agentContext, query))?.firstCredential;
+	}
+};
+W3cCredentialService = __decorate([injectable(), __decorateMetadata("design:paramtypes", [
+	typeof (_ref = typeof W3cCredentialRepository !== "undefined" && W3cCredentialRepository) === "function" ? _ref : Object,
+	typeof (_ref2 = typeof W3cJsonLdCredentialService !== "undefined" && W3cJsonLdCredentialService) === "function" ? _ref2 : Object,
+	typeof (_ref3 = typeof W3cJwtCredentialService !== "undefined" && W3cJwtCredentialService) === "function" ? _ref3 : Object
+])], W3cCredentialService);
+
+//#endregion
+export { W3cCredentialService };
+//# sourceMappingURL=W3cCredentialService.mjs.map

package/build/modules/vc/W3cCredentialService.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialService.mjs","names":["W3cCredentialService"],"sources":["../../../src/modules/vc/W3cCredentialService.ts"],"sourcesContent":["import type { AgentContext } from '../../agent/context'\nimport { CredoError } from '../../error'\nimport { injectable } from '../../plugins'\nimport type { Query, QueryOptions } from '../../storage/StorageService'\nimport { CREDENTIALS_CONTEXT_V1_URL } from './constants'\nimport { W3cJsonLdVerifiableCredential } from './data-integrity'\nimport { W3cJsonLdVerifiablePresentation } from './data-integrity/models/W3cJsonLdVerifiablePresentation'\nimport { W3cJsonLdCredentialService } from './data-integrity/W3cJsonLdCredentialService'\nimport { W3cJwtVerifiableCredential, W3cJwtVerifiablePresentation } from './jwt-vc'\nimport { W3cJwtCredentialService } from './jwt-vc/W3cJwtCredentialService'\nimport type {\n  W3cVerifiableCredential,\n  W3cVerifiablePresentation,\n  W3cVerifyCredentialResult,\n  W3cVerifyPresentationResult,\n} from './models'\nimport { ClaimFormat } from './models'\nimport { W3cPresentation } from './models/presentation/W3cPresentation'\nimport { W3cCredentialRecord, W3cCredentialRepository } from './repository'\nimport type {\n  W3cCreatePresentationOptions,\n  W3cJsonLdVerifyCredentialOptions,\n  W3cJsonLdVerifyPresentationOptions,\n  W3cJwtVerifyCredentialOptions,\n  W3cJwtVerifyPresentationOptions,\n  W3cSignCredentialOptions,\n  W3cSignPresentationOptions,\n  W3cStoreCredentialOptions,\n  W3cVerifyCredentialOptions,\n  W3cVerifyPresentationOptions,\n} from './W3cCredentialServiceOptions'\n\n@injectable()\nexport class W3cCredentialService {\n  private w3cCredentialRepository: W3cCredentialRepository\n  private w3cJsonLdCredentialService: W3cJsonLdCredentialService\n  private w3cJwtCredentialService: W3cJwtCredentialService\n\n  public constructor(\n    w3cCredentialRepository: W3cCredentialRepository,\n    w3cJsonLdCredentialService: W3cJsonLdCredentialService,\n    w3cJwtCredentialService: W3cJwtCredentialService\n  ) {\n    this.w3cCredentialRepository = w3cCredentialRepository\n    this.w3cJsonLdCredentialService = w3cJsonLdCredentialService\n    this.w3cJwtCredentialService = w3cJwtCredentialService\n  }\n\n  /**\n   * Signs a credential\n   *\n   * @param credential the credential to be signed\n   * @returns the signed credential\n   */\n  public async signCredential<Format extends ClaimFormat.JwtVc | ClaimFormat.LdpVc>(\n    agentContext: AgentContext,\n    options: W3cSignCredentialOptions<Format>\n  ): Promise<W3cVerifiableCredential<Format>> {\n    if (options.format === ClaimFormat.JwtVc) {\n      const signed = await this.w3cJwtCredentialService.signCredential(agentContext, options)\n      return signed as W3cVerifiableCredential<Format>\n    }\n    if (options.format === ClaimFormat.LdpVc) {\n      const signed = await this.w3cJsonLdCredentialService.signCredential(agentContext, options)\n      return signed as W3cVerifiableCredential<Format>\n    }\n    throw new CredoError(`Unsupported format in options. Format must be either 'jwt_vc' or 'ldp_vc'`)\n  }\n\n  /**\n   * Verifies the signature(s) of a credential\n   */\n  public async verifyCredential(\n    agentContext: AgentContext,\n    options: W3cVerifyCredentialOptions\n  ): Promise<W3cVerifyCredentialResult> {\n    if (options.credential instanceof W3cJsonLdVerifiableCredential) {\n      return this.w3cJsonLdCredentialService.verifyCredential(agentContext, options as W3cJsonLdVerifyCredentialOptions)\n    }\n    if (options.credential instanceof W3cJwtVerifiableCredential || typeof options.credential === 'string') {\n      return this.w3cJwtCredentialService.verifyCredential(agentContext, options as W3cJwtVerifyCredentialOptions)\n    }\n    throw new CredoError(\n      'Unsupported credential type in options. Credential must be either a W3cJsonLdVerifiableCredential or a W3cJwtVerifiableCredential'\n    )\n  }\n\n  /**\n   * Utility method that creates a {@link W3cPresentation} from one or more {@link W3cJsonLdVerifiableCredential}s.\n   *\n   * **NOTE: the presentation that is returned is unsigned.**\n   *\n   * @returns An instance of {@link W3cPresentation}\n   */\n  public async createPresentation(options: W3cCreatePresentationOptions): Promise<W3cPresentation> {\n    const presentation = new W3cPresentation({\n      context: [CREDENTIALS_CONTEXT_V1_URL],\n      type: ['VerifiablePresentation'],\n      verifiableCredential: options.credentials,\n      holder: options.holder,\n      id: options.id,\n    })\n\n    return presentation\n  }\n\n  /**\n   * Signs a presentation including the credentials it includes\n   *\n   * @param presentation the presentation to be signed\n   * @returns the signed presentation\n   */\n  public async signPresentation<Format extends ClaimFormat.JwtVp | ClaimFormat.LdpVp>(\n    agentContext: AgentContext,\n    options: W3cSignPresentationOptions<Format>\n  ): Promise<W3cVerifiablePresentation<Format>> {\n    if (options.format === ClaimFormat.JwtVp) {\n      const signed = await this.w3cJwtCredentialService.signPresentation(agentContext, options)\n      return signed as W3cVerifiablePresentation<Format>\n    }\n    if (options.format === ClaimFormat.LdpVp) {\n      const signed = await this.w3cJsonLdCredentialService.signPresentation(agentContext, options)\n      return signed as W3cVerifiablePresentation<Format>\n    }\n    throw new CredoError(`Unsupported format in options. Format must be either 'jwt_vp' or 'ldp_vp'`)\n  }\n\n  /**\n   * Verifies a presentation including the credentials it includes\n   *\n   * @param presentation the presentation to be verified\n   * @returns the verification result\n   */\n  public async verifyPresentation(\n    agentContext: AgentContext,\n    options: W3cVerifyPresentationOptions\n  ): Promise<W3cVerifyPresentationResult> {\n    if (options.presentation instanceof W3cJsonLdVerifiablePresentation) {\n      return this.w3cJsonLdCredentialService.verifyPresentation(\n        agentContext,\n        options as W3cJsonLdVerifyPresentationOptions\n      )\n    }\n    if (options.presentation instanceof W3cJwtVerifiablePresentation || typeof options.presentation === 'string') {\n      return this.w3cJwtCredentialService.verifyPresentation(agentContext, options as W3cJwtVerifyPresentationOptions)\n    }\n    throw new CredoError(\n      'Unsupported credential type in options. Presentation must be either a W3cJsonLdVerifiablePresentation or a W3cJwtVerifiablePresentation'\n    )\n  }\n\n  /**\n   * Writes a credential to storage\n   *\n   * @param record the credential to be stored\n   * @returns the credential record that was written to storage\n   */\n  public async storeCredential(\n    agentContext: AgentContext,\n    options: W3cStoreCredentialOptions\n  ): Promise<W3cCredentialRecord> {\n    const credential = options.record.firstCredential\n\n    // JsonLd credentials need expanded types to be stored.\n    if (credential instanceof W3cJsonLdVerifiableCredential && !options.record.getTag('expandedTypes')) {\n      options.record.setTag(\n        'expandedTypes',\n        await this.w3cJsonLdCredentialService.getExpandedTypesForCredential(agentContext, credential)\n      )\n    }\n\n    // Store the w3c credential record\n    await this.w3cCredentialRepository.save(agentContext, options.record)\n\n    return options.record\n  }\n\n  public async removeCredentialRecord(agentContext: AgentContext, id: string) {\n    await this.w3cCredentialRepository.deleteById(agentContext, id)\n  }\n\n  public async getAllCredentialRecords(agentContext: AgentContext): Promise<W3cCredentialRecord[]> {\n    return await this.w3cCredentialRepository.getAll(agentContext)\n  }\n\n  public async getCredentialRecordById(agentContext: AgentContext, id: string): Promise<W3cCredentialRecord> {\n    return await this.w3cCredentialRepository.getById(agentContext, id)\n  }\n\n  public async findCredentialsByQuery(\n    agentContext: AgentContext,\n    query: Query<W3cCredentialRecord>,\n    queryOptions?: QueryOptions\n  ): Promise<W3cVerifiableCredential[]> {\n    const result = await this.w3cCredentialRepository.findByQuery(agentContext, query, queryOptions)\n    return result.map((record) => record.firstCredential)\n  }\n\n  public async findCredentialRecordByQuery(\n    agentContext: AgentContext,\n    query: Query<W3cCredentialRecord>\n  ): Promise<W3cVerifiableCredential | undefined> {\n    const result = await this.w3cCredentialRepository.findSingleByQuery(agentContext, query)\n    return result?.firstCredential\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAiCO,iCAAMA,uBAAqB;CAKhC,AAAO,YACL,yBACA,4BACA,yBACA;AACA,OAAK,0BAA0B;AAC/B,OAAK,6BAA6B;AAClC,OAAK,0BAA0B;;;;;;;;CASjC,MAAa,eACX,cACA,SAC0C;AAC1C,MAAI,QAAQ,WAAW,YAAY,MAEjC,QADe,MAAM,KAAK,wBAAwB,eAAe,cAAc,QAAQ;AAGzF,MAAI,QAAQ,WAAW,YAAY,MAEjC,QADe,MAAM,KAAK,2BAA2B,eAAe,cAAc,QAAQ;AAG5F,QAAM,IAAI,WAAW,4EAA4E;;;;;CAMnG,MAAa,iBACX,cACA,SACoC;AACpC,MAAI,QAAQ,sBAAsB,8BAChC,QAAO,KAAK,2BAA2B,iBAAiB,cAAc,QAA4C;AAEpH,MAAI,QAAQ,sBAAsB,8BAA8B,OAAO,QAAQ,eAAe,SAC5F,QAAO,KAAK,wBAAwB,iBAAiB,cAAc,QAAyC;AAE9G,QAAM,IAAI,WACR,oIACD;;;;;;;;;CAUH,MAAa,mBAAmB,SAAiE;AAS/F,SARqB,IAAI,gBAAgB;GACvC,SAAS,CAAC,2BAA2B;GACrC,MAAM,CAAC,yBAAyB;GAChC,sBAAsB,QAAQ;GAC9B,QAAQ,QAAQ;GAChB,IAAI,QAAQ;GACb,CAAC;;;;;;;;CAWJ,MAAa,iBACX,cACA,SAC4C;AAC5C,MAAI,QAAQ,WAAW,YAAY,MAEjC,QADe,MAAM,KAAK,wBAAwB,iBAAiB,cAAc,QAAQ;AAG3F,MAAI,QAAQ,WAAW,YAAY,MAEjC,QADe,MAAM,KAAK,2BAA2B,iBAAiB,cAAc,QAAQ;AAG9F,QAAM,IAAI,WAAW,4EAA4E;;;;;;;;CASnG,MAAa,mBACX,cACA,SACsC;AACtC,MAAI,QAAQ,wBAAwB,gCAClC,QAAO,KAAK,2BAA2B,mBACrC,cACA,QACD;AAEH,MAAI,QAAQ,wBAAwB,gCAAgC,OAAO,QAAQ,iBAAiB,SAClG,QAAO,KAAK,wBAAwB,mBAAmB,cAAc,QAA2C;AAElH,QAAM,IAAI,WACR,0IACD;;;;;;;;CASH,MAAa,gBACX,cACA,SAC8B;EAC9B,MAAM,aAAa,QAAQ,OAAO;AAGlC,MAAI,sBAAsB,iCAAiC,CAAC,QAAQ,OAAO,OAAO,gBAAgB,CAChG,SAAQ,OAAO,OACb,iBACA,MAAM,KAAK,2BAA2B,8BAA8B,cAAc,WAAW,CAC9F;AAIH,QAAM,KAAK,wBAAwB,KAAK,cAAc,QAAQ,OAAO;AAErE,SAAO,QAAQ;;CAGjB,MAAa,uBAAuB,cAA4B,IAAY;AAC1E,QAAM,KAAK,wBAAwB,WAAW,cAAc,GAAG;;CAGjE,MAAa,wBAAwB,cAA4D;AAC/F,SAAO,MAAM,KAAK,wBAAwB,OAAO,aAAa;;CAGhE,MAAa,wBAAwB,cAA4B,IAA0C;AACzG,SAAO,MAAM,KAAK,wBAAwB,QAAQ,cAAc,GAAG;;CAGrE,MAAa,uBACX,cACA,OACA,cACoC;AAEpC,UADe,MAAM,KAAK,wBAAwB,YAAY,cAAc,OAAO,aAAa,EAClF,KAAK,WAAW,OAAO,gBAAgB;;CAGvD,MAAa,4BACX,cACA,OAC8C;AAE9C,UADe,MAAM,KAAK,wBAAwB,kBAAkB,cAAc,MAAM,GACzE;;;mCA3KlB,YAAY"}

package/build/modules/vc/W3cCredentialServiceOptions.d.mts

@@ -0,0 +1,159 @@
+import { KnownJwaSignatureAlgorithm } from "../kms/jwk/jwa.mjs";
+import { SingleOrArray } from "../../types.mjs";
+import { ClaimFormat } from "./models/ClaimFormat.mjs";
+import { W3cCredential } from "./models/credential/W3cCredential.mjs";
+import { W3cJsonLdVerifiableCredential } from "./data-integrity/models/W3cJsonLdVerifiableCredential.mjs";
+import { W3cCredentialRecord } from "./repository/W3cCredentialRecord.mjs";
+import "./repository/index.mjs";
+import { W3cJwtVerifiableCredential } from "./jwt-vc/W3cJwtVerifiableCredential.mjs";
+import { W3cVerifiableCredential } from "./models/credential/W3cVerifiableCredential.mjs";
+import { W3cPresentation } from "./models/presentation/W3cPresentation.mjs";
+import "./models/index.mjs";
+import { W3cJwtVerifiablePresentation } from "./jwt-vc/W3cJwtVerifiablePresentation.mjs";
+import { W3cJsonLdVerifiablePresentation } from "./data-integrity/models/W3cJsonLdVerifiablePresentation.mjs";
+import { ProofPurpose } from "./data-integrity/proof-purposes/ProofPurpose.mjs";
+import "./data-integrity/index.mjs";
+import "../kms/index.mjs";
+
+//#region src/modules/vc/W3cCredentialServiceOptions.d.ts
+type W3cSignCredentialOptions<Format extends ClaimFormat.JwtVc | ClaimFormat.LdpVc | undefined = undefined> = Format extends ClaimFormat.JwtVc ? W3cJwtSignCredentialOptions : Format extends ClaimFormat.LdpVc ? W3cJsonLdSignCredentialOptions : W3cJwtSignCredentialOptions | W3cJsonLdSignCredentialOptions;
+type W3cVerifyCredentialOptions<Format extends ClaimFormat.JwtVc | ClaimFormat.LdpVc | undefined = undefined> = Format extends ClaimFormat.JwtVc ? W3cJwtVerifyCredentialOptions : Format extends ClaimFormat.LdpVc ? W3cJsonLdVerifyCredentialOptions : W3cJwtVerifyCredentialOptions | W3cJsonLdVerifyCredentialOptions;
+type W3cSignPresentationOptions<Format extends ClaimFormat.JwtVp | ClaimFormat.LdpVp | undefined = undefined> = Format extends ClaimFormat.JwtVp ? W3cJwtSignPresentationOptions : Format extends ClaimFormat.LdpVp ? W3cJsonLdSignPresentationOptions : W3cJwtSignPresentationOptions | W3cJsonLdSignPresentationOptions;
+type W3cVerifyPresentationOptions = W3cJwtVerifyPresentationOptions | W3cJsonLdVerifyPresentationOptions;
+interface W3cSignCredentialOptionsBase {
+  /**
+   * The format of the credential to be signed.
+   *
+   * @see https://identity.foundation/claim-format-registry
+   */
+  format: ClaimFormat;
+  /**
+   * The credential to be signed.
+   */
+  credential: W3cCredential;
+  /**
+   * URI of the verificationMethod to be used for signing the credential.
+   *
+   * Must be a valid did url pointing to a key.
+   */
+  verificationMethod: string;
+}
+interface W3cJwtSignCredentialOptions extends W3cSignCredentialOptionsBase {
+  format: ClaimFormat.JwtVc;
+  /**
+   * The alg to be used for signing the credential.
+   *
+   * Must be a valid JWA signature algorithm.
+   */
+  alg: KnownJwaSignatureAlgorithm;
+}
+interface W3cJsonLdSignCredentialOptions extends W3cSignCredentialOptionsBase {
+  /**
+   * The format of the credential to be signed. Must be either `jwt_vc` or `ldp_vc`.
+   * @see https://identity.foundation/claim-format-registry
+   */
+  format: ClaimFormat.LdpVc;
+  /**
+   * The proofType to be used for signing the credential.
+   *
+   * Must be a valid Linked Data Signature suite.
+   */
+  proofType: string;
+  proofPurpose?: ProofPurpose;
+  created?: string;
+}
+interface W3cVerifyCredentialOptionsBase {
+  credential: unknown;
+  /**
+   * Whether to verify the credentialStatus, if present.
+   */
+  verifyCredentialStatus?: boolean;
+}
+interface W3cJwtVerifyCredentialOptions extends W3cVerifyCredentialOptionsBase {
+  credential: W3cJwtVerifiableCredential | string;
+}
+interface W3cJsonLdVerifyCredentialOptions extends W3cVerifyCredentialOptionsBase {
+  credential: W3cJsonLdVerifiableCredential;
+  proofPurpose?: ProofPurpose;
+}
+interface W3cCreatePresentationOptions {
+  credentials: SingleOrArray<W3cVerifiableCredential>;
+  id?: string;
+  holder?: string;
+}
+interface W3cSignPresentationOptionsBase {
+  /**
+   * The format of the presentation to be signed.
+   *
+   * @see https://identity.foundation/claim-format-registry
+   */
+  format: ClaimFormat;
+  /**
+   * The presentation to be signed.
+   */
+  presentation: W3cPresentation;
+  /**
+   * URI of the verificationMethod to be used for signing the presentation.
+   *
+   * Must be a valid did url pointing to a key.
+   */
+  verificationMethod: string;
+  /**
+   * The challenge / nonce to be used in the proof to prevent replay attacks.
+   */
+  challenge?: string;
+  /**
+   * The domain / aud to be used in the proof to assert the intended recipient.
+   */
+  domain?: string;
+}
+interface W3cJsonLdSignPresentationOptions extends W3cSignPresentationOptionsBase {
+  format: ClaimFormat.LdpVp;
+  /**
+   * The proofType to be used for signing the presentation.
+   *
+   * Must be a valid Linked Data Signature suite.
+   */
+  proofType: string;
+  proofPurpose: ProofPurpose;
+}
+interface W3cJwtSignPresentationOptions extends W3cSignPresentationOptionsBase {
+  format: ClaimFormat.JwtVp;
+  /**
+   * The alg to be used for signing the presentation.
+   *
+   * Must be a valid JWA signature algorithm.
+   */
+  alg: KnownJwaSignatureAlgorithm;
+}
+interface W3cVerifyPresentationOptionsBase {
+  /**
+   * The presentation to be verified.
+   */
+  presentation: unknown;
+  /**
+   * The challenge / nonce that must present in the presentation prevent replay attacks.
+   */
+  challenge: string;
+  /**
+   * The domain / aud to be used in the proof to assert the intended recipient.
+   */
+  domain?: string;
+  /**
+   * Whether to verify the credentialStatus, if present.
+   */
+  verifyCredentialStatus?: boolean;
+}
+interface W3cJwtVerifyPresentationOptions extends W3cVerifyPresentationOptionsBase {
+  presentation: W3cJwtVerifiablePresentation | string;
+}
+interface W3cJsonLdVerifyPresentationOptions extends W3cVerifyPresentationOptionsBase {
+  presentation: W3cJsonLdVerifiablePresentation;
+  purpose?: ProofPurpose;
+}
+type W3cStoreCredentialOptions = {
+  record: W3cCredentialRecord;
+};
+//#endregion
+export { W3cCreatePresentationOptions, W3cJsonLdSignCredentialOptions, W3cJsonLdSignPresentationOptions, W3cJsonLdVerifyCredentialOptions, W3cJsonLdVerifyPresentationOptions, W3cJwtSignCredentialOptions, W3cJwtSignPresentationOptions, W3cJwtVerifyCredentialOptions, W3cJwtVerifyPresentationOptions, W3cSignCredentialOptions, W3cSignPresentationOptions, W3cStoreCredentialOptions, W3cVerifyCredentialOptions, W3cVerifyPresentationOptions };
+//# sourceMappingURL=W3cCredentialServiceOptions.d.mts.map

package/build/modules/vc/W3cCredentialServiceOptions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialServiceOptions.d.mts","names":[],"sources":["../../../src/modules/vc/W3cCredentialServiceOptions.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;KAWY,wCAAwC,WAAA,CAAY,QAAQ,WAAA,CAAY,iCAClF,eAAe,WAAA,CAAY,QACvB,8BACA,eAAe,WAAA,CAAY,QACzB,iCACA,8BAA8B;KAC1B,0CAA0C,WAAA,CAAY,QAAQ,WAAA,CAAY,iCACpF,eAAe,WAAA,CAAY,QACvB,gCACA,eAAe,WAAA,CAAY,QACzB,mCACA,gCAAgC;KAC5B,0CAA0C,WAAA,CAAY,QAAQ,WAAA,CAAY,iCACpF,eAAe,WAAA,CAAY,QACvB,gCACA,eAAe,WAAA,CAAY,QACzB,mCACA,gCAAgC;KAC5B,4BAAA,GAA+B,kCAAkC;UAEnE,4BAAA;;;;;;EApBE,MAAA,EA0BF,WA1BE;EAAwC;;;EACnC,UAAY,EA8Bf,aA9Be;EACvB;;;;;EAGgC,kBAAA,EAAA,MAAA;;AAC1B,UAmCK,2BAAA,SAAoC,4BAnCf,CAAA;EAAgB,MAAA,EAoC5C,WAAA,CAAY,KApC4C;EAAQ;;;;;EAGrD,GAAA,EAwCd,0BAxC0B;;AAEzB,UAyCS,8BAAA,SAAuC,4BAzChD,CAAA;EAAgC;;AACxC;;EAA0E,MAAA,EA6ChE,WAAA,CAAY,KA7CgE;EACpF;;;;;EAGM,SAAA,EAAA,MAAA;EACA,YAAA,CAAA,EAiDS,YAjDT;EAAgC,OAAA,CAAA,EAAA,MAAA;;AACxC,UAoDU,8BAAA,CApD8B;EAE9B,UAAA,EAAA,OAAA;EAqBO;;;EAAoC,sBAAA,CAAA,EAAA,OAAA;;AAWpC,UA2BA,6BAAA,SAAsC,8BA3BP,CAAA;EAKtC,UAAY,EAuBR,0BAvBQ,GAAA,MAAA;;AALkC,UA+BvC,gCAAA,SAAyC,8BA/BF,CAAA;EAA4B,UAAA,EAgCtE,6BAhCsE;EAkB1E,YAAA,CAAA,EAeO,YAfP;AASV;AAIiB,UAKA,4BAAA,CALiC;EACpC,WAAA,EAKC,aALD,CAKe,uBALf,CAAA;EACG,EAAA,CAAA,EAAA,MAAA;EAFyC,MAAA,CAAA,EAAA,MAAA;;AAK1D,UAMU,8BAAA,CANmC;EAMnC;AA+BV;;;;EAAwF,MAAA,EAzB9E,WAyB8E;EAavE;;;EAAsC,YAAA,EAjCvC,eAiCuC;EAA8B;AASpF;AAwBD;AAIA;;EAEY,kBAAA,EAAA,MAAA;EAFgD;;AAK5D;;;;;;;UAvDiB,gCAAA,SAAyC;UAChD,WAAA,CAAY;;;;;;;gBASN;;UAGC,6BAAA,SAAsC;UAC7C,WAAA,CAAY;;;;;;OAOf;;UAGG,gCAAA;;;;;;;;;;;;;;;;;;UAsBO,+BAAA,SAAwC;gBACzC;;UAGC,kCAAA,SAA2C;gBAC5C;YACJ;;KAGA,yBAAA;UACF"}

package/build/modules/vc/W3cCredentialServiceOptions.mjs

@@ -0,0 +1,3 @@
+
+
+import "./repository/index.mjs";

package/build/modules/vc/W3cCredentialsApi.d.mts

@@ -0,0 +1,36 @@
+import { Query, QueryOptions } from "../../storage/StorageService.mjs";
+import { ClaimFormat } from "./models/ClaimFormat.mjs";
+import { W3cCredentialRecord } from "./repository/W3cCredentialRecord.mjs";
+import "./repository/index.mjs";
+import { W3cVerifiableCredential } from "./models/credential/W3cVerifiableCredential.mjs";
+import { W3cPresentation } from "./models/presentation/W3cPresentation.mjs";
+import { W3cVerifiablePresentation } from "./models/presentation/W3cVerifiablePresentation.mjs";
+import { W3cVerifyCredentialResult, W3cVerifyPresentationResult } from "./models/W3cVerifyResult.mjs";
+import "./models/index.mjs";
+import { W3cCreatePresentationOptions, W3cSignCredentialOptions, W3cSignPresentationOptions, W3cStoreCredentialOptions, W3cVerifyCredentialOptions, W3cVerifyPresentationOptions } from "./W3cCredentialServiceOptions.mjs";
+import { W3cCredentialService } from "./W3cCredentialService.mjs";
+import { AgentContext } from "../../agent/context/AgentContext.mjs";
+import "../../agent/index.mjs";
+
+//#region src/modules/vc/W3cCredentialsApi.d.ts
+/**
+ * @public
+ */
+declare class W3cCredentialsApi {
+  private agentContext;
+  private w3cCredentialService;
+  constructor(agentContext: AgentContext, w3cCredentialService: W3cCredentialService);
+  store(options: W3cStoreCredentialOptions): Promise<W3cCredentialRecord>;
+  deleteById(id: string): Promise<void>;
+  getAll(): Promise<W3cCredentialRecord[]>;
+  getById(id: string): Promise<W3cCredentialRecord>;
+  findAllByQuery(query: Query<W3cCredentialRecord>, queryOptions?: QueryOptions): Promise<W3cVerifiableCredential[]>;
+  signCredential<Format extends ClaimFormat.JwtVc | ClaimFormat.LdpVc>(options: W3cSignCredentialOptions<Format>): Promise<W3cVerifiableCredential<Format>>;
+  verifyCredential(options: W3cVerifyCredentialOptions): Promise<W3cVerifyCredentialResult>;
+  createPresentation(options: W3cCreatePresentationOptions): Promise<W3cPresentation>;
+  signPresentation<Format extends ClaimFormat.JwtVp | ClaimFormat.LdpVp>(options: W3cSignPresentationOptions<Format>): Promise<W3cVerifiablePresentation<Format>>;
+  verifyPresentation(options: W3cVerifyPresentationOptions): Promise<W3cVerifyPresentationResult>;
+}
+//#endregion
+export { W3cCredentialsApi };
+//# sourceMappingURL=W3cCredentialsApi.d.mts.map

package/build/modules/vc/W3cCredentialsApi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialsApi.d.mts","names":[],"sources":["../../../src/modules/vc/W3cCredentialsApi.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;cAmBa,iBAAA;;;4BAIsB,oCAAoC;iBAKzC,4BAA4B,QAAQ;0BAI9B;YAIX,QAAQ;uBAIG,QAAQ;EArB/B,cAAA,CAAA,KAAiB,EA0BnB,KA1BmB,CA0Bb,mBA1Ba,CAAA,EAAA,YAAA,CAAA,EA2BX,YA3BW,CAAA,EA4BzB,OA5ByB,CA4BjB,uBA5BiB,EAAA,CAAA;EAIK,cAAA,CAAA,eA4BU,WAAA,CAAY,KA5BtB,GA4B8B,WAAA,CAAY,KA5B1C,CAAA,CAAA,OAAA,EA6BtB,wBA7BsB,CA6BG,MA7BH,CAAA,CAAA,EA6BU,OA7BV,CA6BU,uBA7BV,CA6BU,MA7BV,CAAA,CAAA;EAAoC,gBAAA,CAAA,OAAA,EAkC9B,0BAlC8B,CAAA,EAkCJ,OAlCI,CAkCJ,yBAAA,CAlCI;EAKzC,kBAAA,CAAA,OAAA,EAiCa,4BAjCb,CAAA,EAiCyC,OAjCzC,CAiCyC,eAAA,CAjCzC;EAAoC,gBAAA,CAAA,eAqCnB,WAAA,CAAY,KArCO,GAqCC,WAAA,CAAY,KArCb,CAAA,CAAA,OAAA,EAsCrD,0BAtCqD,CAsC1B,MAtC0B,CAAA,CAAA,EAsCnB,OAtCmB,CAsCnB,yBAtCmB,CAsCnB,MAtCmB,CAAA,CAAA;EAAR,kBAAA,CAAA,OAAA,EA2Cf,4BA3Ce,CAAA,EA2Ca,OA3Cb,CA2Ca,2BAAA,CA3Cb"}

package/build/modules/vc/W3cCredentialsApi.mjs

@@ -0,0 +1,52 @@
+
+
+import { AgentContext } from "../../agent/context/AgentContext.mjs";
+import { injectable } from "../../plugins/index.mjs";
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import "../../agent/index.mjs";
+import { W3cCredentialService } from "./W3cCredentialService.mjs";
+
+//#region src/modules/vc/W3cCredentialsApi.ts
+var _ref, _ref2;
+let W3cCredentialsApi = class W3cCredentialsApi$1 {
+	constructor(agentContext, w3cCredentialService) {
+		this.agentContext = agentContext;
+		this.w3cCredentialService = w3cCredentialService;
+	}
+	async store(options) {
+		return this.w3cCredentialService.storeCredential(this.agentContext, options);
+	}
+	async deleteById(id) {
+		return this.w3cCredentialService.removeCredentialRecord(this.agentContext, id);
+	}
+	async getAll() {
+		return this.w3cCredentialService.getAllCredentialRecords(this.agentContext);
+	}
+	async getById(id) {
+		return this.w3cCredentialService.getCredentialRecordById(this.agentContext, id);
+	}
+	async findAllByQuery(query, queryOptions) {
+		return this.w3cCredentialService.findCredentialsByQuery(this.agentContext, query, queryOptions);
+	}
+	async signCredential(options) {
+		return this.w3cCredentialService.signCredential(this.agentContext, options);
+	}
+	async verifyCredential(options) {
+		return this.w3cCredentialService.verifyCredential(this.agentContext, options);
+	}
+	async createPresentation(options) {
+		return this.w3cCredentialService.createPresentation(options);
+	}
+	async signPresentation(options) {
+		return this.w3cCredentialService.signPresentation(this.agentContext, options);
+	}
+	async verifyPresentation(options) {
+		return this.w3cCredentialService.verifyPresentation(this.agentContext, options);
+	}
+};
+W3cCredentialsApi = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof AgentContext !== "undefined" && AgentContext) === "function" ? _ref : Object, typeof (_ref2 = typeof W3cCredentialService !== "undefined" && W3cCredentialService) === "function" ? _ref2 : Object])], W3cCredentialsApi);
+
+//#endregion
+export { W3cCredentialsApi };
+//# sourceMappingURL=W3cCredentialsApi.mjs.map

package/build/modules/vc/W3cCredentialsApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialsApi.mjs","names":["W3cCredentialsApi"],"sources":["../../../src/modules/vc/W3cCredentialsApi.ts"],"sourcesContent":["import { AgentContext } from '../../agent'\nimport { injectable } from '../../plugins'\nimport type { Query, QueryOptions } from '../../storage/StorageService'\nimport type { ClaimFormat, W3cVerifiableCredential } from './models'\nimport type { W3cCredentialRecord } from './repository'\nimport { W3cCredentialService } from './W3cCredentialService'\nimport type {\n  W3cCreatePresentationOptions,\n  W3cSignCredentialOptions,\n  W3cSignPresentationOptions,\n  W3cStoreCredentialOptions,\n  W3cVerifyCredentialOptions,\n  W3cVerifyPresentationOptions,\n} from './W3cCredentialServiceOptions'\n\n/**\n * @public\n */\n@injectable()\nexport class W3cCredentialsApi {\n  private agentContext: AgentContext\n  private w3cCredentialService: W3cCredentialService\n\n  public constructor(agentContext: AgentContext, w3cCredentialService: W3cCredentialService) {\n    this.agentContext = agentContext\n    this.w3cCredentialService = w3cCredentialService\n  }\n\n  public async store(options: W3cStoreCredentialOptions): Promise<W3cCredentialRecord> {\n    return this.w3cCredentialService.storeCredential(this.agentContext, options)\n  }\n\n  public async deleteById(id: string) {\n    return this.w3cCredentialService.removeCredentialRecord(this.agentContext, id)\n  }\n\n  public async getAll(): Promise<W3cCredentialRecord[]> {\n    return this.w3cCredentialService.getAllCredentialRecords(this.agentContext)\n  }\n\n  public async getById(id: string): Promise<W3cCredentialRecord> {\n    return this.w3cCredentialService.getCredentialRecordById(this.agentContext, id)\n  }\n\n  public async findAllByQuery(\n    query: Query<W3cCredentialRecord>,\n    queryOptions?: QueryOptions\n  ): Promise<W3cVerifiableCredential[]> {\n    return this.w3cCredentialService.findCredentialsByQuery(this.agentContext, query, queryOptions)\n  }\n\n  public async signCredential<Format extends ClaimFormat.JwtVc | ClaimFormat.LdpVc>(\n    options: W3cSignCredentialOptions<Format>\n  ) {\n    return this.w3cCredentialService.signCredential<Format>(this.agentContext, options)\n  }\n\n  public async verifyCredential(options: W3cVerifyCredentialOptions) {\n    return this.w3cCredentialService.verifyCredential(this.agentContext, options)\n  }\n\n  public async createPresentation(options: W3cCreatePresentationOptions) {\n    return this.w3cCredentialService.createPresentation(options)\n  }\n\n  public async signPresentation<Format extends ClaimFormat.JwtVp | ClaimFormat.LdpVp>(\n    options: W3cSignPresentationOptions<Format>\n  ) {\n    return this.w3cCredentialService.signPresentation<Format>(this.agentContext, options)\n  }\n\n  public async verifyPresentation(options: W3cVerifyPresentationOptions) {\n    return this.w3cCredentialService.verifyPresentation(this.agentContext, options)\n  }\n}\n"],"mappings":";;;;;;;;;;;AAmBO,8BAAMA,oBAAkB;CAI7B,AAAO,YAAY,cAA4B,sBAA4C;AACzF,OAAK,eAAe;AACpB,OAAK,uBAAuB;;CAG9B,MAAa,MAAM,SAAkE;AACnF,SAAO,KAAK,qBAAqB,gBAAgB,KAAK,cAAc,QAAQ;;CAG9E,MAAa,WAAW,IAAY;AAClC,SAAO,KAAK,qBAAqB,uBAAuB,KAAK,cAAc,GAAG;;CAGhF,MAAa,SAAyC;AACpD,SAAO,KAAK,qBAAqB,wBAAwB,KAAK,aAAa;;CAG7E,MAAa,QAAQ,IAA0C;AAC7D,SAAO,KAAK,qBAAqB,wBAAwB,KAAK,cAAc,GAAG;;CAGjF,MAAa,eACX,OACA,cACoC;AACpC,SAAO,KAAK,qBAAqB,uBAAuB,KAAK,cAAc,OAAO,aAAa;;CAGjG,MAAa,eACX,SACA;AACA,SAAO,KAAK,qBAAqB,eAAuB,KAAK,cAAc,QAAQ;;CAGrF,MAAa,iBAAiB,SAAqC;AACjE,SAAO,KAAK,qBAAqB,iBAAiB,KAAK,cAAc,QAAQ;;CAG/E,MAAa,mBAAmB,SAAuC;AACrE,SAAO,KAAK,qBAAqB,mBAAmB,QAAQ;;CAG9D,MAAa,iBACX,SACA;AACA,SAAO,KAAK,qBAAqB,iBAAyB,KAAK,cAAc,QAAQ;;CAGvF,MAAa,mBAAmB,SAAuC;AACrE,SAAO,KAAK,qBAAqB,mBAAmB,KAAK,cAAc,QAAQ;;;gCAtDlF,YAAY"}

package/build/modules/vc/W3cCredentialsModule.d.mts

@@ -0,0 +1,19 @@
+import { W3cCredentialsModuleConfig, W3cCredentialsModuleConfigOptions } from "./W3cCredentialsModuleConfig.mjs";
+import { W3cCredentialsApi } from "./W3cCredentialsApi.mjs";
+import { DependencyManager } from "../../plugins/DependencyManager.mjs";
+import { Module } from "../../plugins/Module.mjs";
+import "../../plugins/index.mjs";
+
+//#region src/modules/vc/W3cCredentialsModule.d.ts
+/**
+ * @public
+ */
+declare class W3cCredentialsModule implements Module {
+  readonly config: W3cCredentialsModuleConfig;
+  readonly api: typeof W3cCredentialsApi;
+  constructor(config?: W3cCredentialsModuleConfigOptions);
+  register(dependencyManager: DependencyManager): void;
+}
+//#endregion
+export { W3cCredentialsModule };
+//# sourceMappingURL=W3cCredentialsModule.d.mts.map

package/build/modules/vc/W3cCredentialsModule.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialsModule.d.mts","names":[],"sources":["../../../src/modules/vc/W3cCredentialsModule.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAmBa,oBAAA,YAAgC;mBACnB;EADb,SAAA,GAAA,EAAA,OAEQ,iBAFa;EACR,WAAA,CAAA,MAAA,CAAA,EAGI,iCAHJ;EACL,QAAA,CAAA,iBAAA,EAMgB,iBANhB,CAAA,EAAA,IAAA"}

package/build/modules/vc/W3cCredentialsModule.mjs

@@ -0,0 +1,53 @@
+
+
+import { Ed25519PublicJwk } from "../kms/jwk/kty/okp/Ed25519PublicJwk.mjs";
+import "../kms/index.mjs";
+import { VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018 } from "../dids/domain/verificationMethod/Ed25519VerificationKey2018.mjs";
+import { VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020 } from "../dids/domain/verificationMethod/Ed25519VerificationKey2020.mjs";
+import "../dids/index.mjs";
+import { W3cJwtCredentialService } from "./jwt-vc/W3cJwtCredentialService.mjs";
+import "./jwt-vc/index.mjs";
+import { SignatureSuiteRegistry, SignatureSuiteToken } from "./data-integrity/SignatureSuiteRegistry.mjs";
+import { Ed25519Signature2018 } from "./data-integrity/signature-suites/ed25519/Ed25519Signature2018.mjs";
+import { Ed25519Signature2020 } from "./data-integrity/signature-suites/ed25519/Ed25519Signature2020.mjs";
+import "./data-integrity/signature-suites/index.mjs";
+import { W3cCredentialsModuleConfig } from "./W3cCredentialsModuleConfig.mjs";
+import { W3cJsonLdCredentialService } from "./data-integrity/W3cJsonLdCredentialService.mjs";
+import { W3cCredentialRepository } from "./repository/W3cCredentialRepository.mjs";
+import { W3cCredentialService } from "./W3cCredentialService.mjs";
+import { W3cCredentialsApi } from "./W3cCredentialsApi.mjs";
+
+//#region src/modules/vc/W3cCredentialsModule.ts
+/**
+* @public
+*/
+var W3cCredentialsModule = class {
+	constructor(config) {
+		this.api = W3cCredentialsApi;
+		this.config = new W3cCredentialsModuleConfig(config);
+	}
+	register(dependencyManager) {
+		dependencyManager.registerSingleton(W3cCredentialService);
+		dependencyManager.registerSingleton(W3cJwtCredentialService);
+		dependencyManager.registerSingleton(W3cJsonLdCredentialService);
+		dependencyManager.registerSingleton(W3cCredentialRepository);
+		dependencyManager.registerSingleton(SignatureSuiteRegistry);
+		dependencyManager.registerInstance(W3cCredentialsModuleConfig, this.config);
+		dependencyManager.registerInstance(SignatureSuiteToken, {
+			suiteClass: Ed25519Signature2018,
+			proofType: "Ed25519Signature2018",
+			verificationMethodTypes: [VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018, VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020],
+			supportedPublicJwkTypes: [Ed25519PublicJwk]
+		});
+		dependencyManager.registerInstance(SignatureSuiteToken, {
+			suiteClass: Ed25519Signature2020,
+			proofType: "Ed25519Signature2020",
+			verificationMethodTypes: [VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020],
+			supportedPublicJwkTypes: [Ed25519PublicJwk]
+		});
+	}
+};
+
+//#endregion
+export { W3cCredentialsModule };
+//# sourceMappingURL=W3cCredentialsModule.mjs.map

package/build/modules/vc/W3cCredentialsModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialsModule.mjs","names":[],"sources":["../../../src/modules/vc/W3cCredentialsModule.ts"],"sourcesContent":["import type { DependencyManager, Module } from '../../plugins'\nimport {\n  VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018,\n  VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020,\n} from '../dids'\nimport { Ed25519PublicJwk } from '../kms'\nimport { SignatureSuiteRegistry, SignatureSuiteToken, type SuiteInfo } from './data-integrity/SignatureSuiteRegistry'\nimport { Ed25519Signature2018, Ed25519Signature2020 } from './data-integrity/signature-suites'\nimport { W3cJsonLdCredentialService } from './data-integrity/W3cJsonLdCredentialService'\nimport { W3cJwtCredentialService } from './jwt-vc'\nimport { W3cCredentialRepository } from './repository/W3cCredentialRepository'\nimport { W3cCredentialService } from './W3cCredentialService'\nimport { W3cCredentialsApi } from './W3cCredentialsApi'\nimport type { W3cCredentialsModuleConfigOptions } from './W3cCredentialsModuleConfig'\nimport { W3cCredentialsModuleConfig } from './W3cCredentialsModuleConfig'\n\n/**\n * @public\n */\nexport class W3cCredentialsModule implements Module {\n  public readonly config: W3cCredentialsModuleConfig\n  public readonly api = W3cCredentialsApi\n\n  public constructor(config?: W3cCredentialsModuleConfigOptions) {\n    this.config = new W3cCredentialsModuleConfig(config)\n  }\n\n  public register(dependencyManager: DependencyManager) {\n    dependencyManager.registerSingleton(W3cCredentialService)\n    dependencyManager.registerSingleton(W3cJwtCredentialService)\n    dependencyManager.registerSingleton(W3cJsonLdCredentialService)\n    dependencyManager.registerSingleton(W3cCredentialRepository)\n\n    dependencyManager.registerSingleton(SignatureSuiteRegistry)\n\n    // Register the config\n    dependencyManager.registerInstance(W3cCredentialsModuleConfig, this.config)\n\n    // Always register ed25519 signature suite\n    dependencyManager.registerInstance(SignatureSuiteToken, {\n      suiteClass: Ed25519Signature2018,\n      proofType: 'Ed25519Signature2018',\n      verificationMethodTypes: [\n        VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2018,\n        VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020,\n      ],\n      supportedPublicJwkTypes: [Ed25519PublicJwk],\n    } satisfies SuiteInfo)\n    dependencyManager.registerInstance(SignatureSuiteToken, {\n      suiteClass: Ed25519Signature2020,\n      proofType: 'Ed25519Signature2020',\n      verificationMethodTypes: [VERIFICATION_METHOD_TYPE_ED25519_VERIFICATION_KEY_2020],\n      supportedPublicJwkTypes: [Ed25519PublicJwk],\n    } satisfies SuiteInfo)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAmBA,IAAa,uBAAb,MAAoD;CAIlD,AAAO,YAAY,QAA4C;OAF/C,MAAM;AAGpB,OAAK,SAAS,IAAI,2BAA2B,OAAO;;CAGtD,AAAO,SAAS,mBAAsC;AACpD,oBAAkB,kBAAkB,qBAAqB;AACzD,oBAAkB,kBAAkB,wBAAwB;AAC5D,oBAAkB,kBAAkB,2BAA2B;AAC/D,oBAAkB,kBAAkB,wBAAwB;AAE5D,oBAAkB,kBAAkB,uBAAuB;AAG3D,oBAAkB,iBAAiB,4BAA4B,KAAK,OAAO;AAG3E,oBAAkB,iBAAiB,qBAAqB;GACtD,YAAY;GACZ,WAAW;GACX,yBAAyB,CACvB,wDACA,uDACD;GACD,yBAAyB,CAAC,iBAAiB;GAC5C,CAAqB;AACtB,oBAAkB,iBAAiB,qBAAqB;GACtD,YAAY;GACZ,WAAW;GACX,yBAAyB,CAAC,uDAAuD;GACjF,yBAAyB,CAAC,iBAAiB;GAC5C,CAAqB"}

package/build/modules/vc/W3cCredentialsModuleConfig.d.mts

@@ -0,0 +1,41 @@
+import { DocumentLoaderWithContext } from "./data-integrity/libraries/documentLoader.mjs";
+
+//#region src/modules/vc/W3cCredentialsModuleConfig.d.ts
+/**
+ * W3cCredentialsModuleConfigOptions defines the interface for the options of the W3cCredentialsModuleConfig class.
+ * This can contain optional parameters that have default values in the config class itself.
+ */
+interface W3cCredentialsModuleConfigOptions {
+  /**
+   * Document loader to use for resolving JSON-LD objects. Takes a {@link AgentContext} as parameter,
+   * and must return a {@link DocumentLoader} function.
+   *
+   * @example
+   * ```
+   * const myDocumentLoader = (agentContext: AgentContext) => {
+   *   return async (url) => {
+   *     if (url !== 'https://example.org') throw new Error("I don't know how to load this document")
+   *
+   *     return {
+   *       contextUrl: null,
+   *       documentUrl: url,
+   *       document: null
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   *
+   * @default {@link defaultDocumentLoader}
+   */
+  documentLoader?: DocumentLoaderWithContext;
+}
+declare class W3cCredentialsModuleConfig {
+  private options;
+  constructor(options?: W3cCredentialsModuleConfigOptions);
+  /** See {@link W3cCredentialsModuleConfigOptions.documentLoader} */
+  get documentLoader(): DocumentLoaderWithContext;
+}
+//#endregion
+export { W3cCredentialsModuleConfig, W3cCredentialsModuleConfigOptions };
+//# sourceMappingURL=W3cCredentialsModuleConfig.d.mts.map

package/build/modules/vc/W3cCredentialsModuleConfig.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cCredentialsModuleConfig.d.mts","names":[],"sources":["../../../src/modules/vc/W3cCredentialsModuleConfig.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQiB,UAAA,iCAAA,CAAiC;EA0BrC;;;;;;;;;;;;;;;;;;;;;;mBAHM;;cAGN,0BAAA;;wBAGkB;;wBAKJ"}