@sphereon/ssi-sdk.wellknown-did-issuer 0.33.1-feature.vcdm2.4 → 0.33.1-feature.vcdm2.tsup.19

package/dist/index.js

@@ -1,12 +1,582 @@
-import { DidConfigurationResourceEntity } from './entities/DidConfigurationResourceEntity';
-/**
- * @public
- */
-const schema = require('../plugin.schema.json');
-export { schema };
-export { DidConfigurationResourceEntity } from './entities/DidConfigurationResourceEntity';
-export { WellKnownDidIssuer } from './agent/WellKnownDidIssuer';
-export * from './types/IWellKnownDidIssuer';
-export const WellknownDidIssuerEntities = [DidConfigurationResourceEntity];
-export { WellknownDidIssuerMigrations } from './migrations';
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module) {
+    module.exports = {
+      IWellKnownDidIssuer: {
+        components: {
+          schemas: {
+            IIssueDidConfigurationResourceArgs: {
+              type: "object",
+              properties: {
+                issuances: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      additionalProperties: true
+                    }
+                  }
+                },
+                credentialIssuance: {
+                  type: "string"
+                },
+                save: {
+                  type: "boolean"
+                },
+                additionalProperties: false
+              },
+              required: ["issuances", "credentialIssuance"],
+              description: "Arguments needed for {@link IWellKnownDidIssuer.addLinkedDomainsService } "
+            },
+            IIssueDomainLinkageCredentialArgs: {
+              type: "object",
+              properties: {
+                did: {
+                  type: "string"
+                },
+                origin: {
+                  type: "string"
+                },
+                serviceId: {
+                  type: "string"
+                },
+                issuanceDate: {
+                  type: "date"
+                },
+                expirationDate: {
+                  type: "date"
+                },
+                save: {
+                  type: "boolean"
+                },
+                options: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                credentialIssuance: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["did", "origin", "expirationDate", "options"],
+              description: "Arguments needed for {@link IWellKnownDidIssuer.issueDomainLinkageCredential } "
+            },
+            IGetDidConfigurationResourceArgs: {
+              type: "object",
+              properties: {
+                origin: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["origin"],
+              description: "Arguments needed for {@link IWellKnownDidIssuer.getDidConfigurationResource } "
+            },
+            IAddLinkedDomainsServiceArgs: {
+              type: "object",
+              properties: {
+                did: {
+                  type: "string"
+                },
+                origin: {
+                  type: "string"
+                },
+                serviceId: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["did", "origin"],
+              description: "Arguments needed for {@link IWellKnownDidIssuer.addLinkedDomainsService } "
+            },
+            ISaveDidConfigurationResourceArgs: {
+              type: "object",
+              properties: {
+                origin: {
+                  type: "string"
+                },
+                didConfigurationResource: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["did", "origin"],
+              description: "Arguments needed for {@link IWellKnownDidIssuer.saveDidConfigurationResource } "
+            },
+            IRemoveCredentialIssuanceArgs: {
+              type: "object",
+              properties: {
+                origin: {
+                  callbackName: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["callbackName"],
+              description: "Arguments needed for {@link IWellKnownDidIssuer.removeCredentialIssuance } "
+            }
+          },
+          methods: {
+            addLinkedDomainsService: {
+              description: "Adds a LinkedDomains service to the DID",
+              arguments: {
+                $ref: "#/components/schemas/IAddLinkedDomainsServiceArgs"
+              }
+            },
+            getDidConfigurationResource: {
+              description: "Retrieves a DID configuration resource from the database",
+              arguments: {
+                $ref: "#/components/schemas/IGetDidConfigurationResourceArgs"
+              },
+              returnType: "object"
+            },
+            issueDidConfigurationResource: {
+              description: "Issues a DID configuration resource",
+              arguments: {
+                $ref: "#/components/schemas/IAddLinkedDomainsServiceArgs"
+              },
+              returnType: "object"
+            },
+            issueDomainLinkageCredential: {
+              description: "Retrieves a domain linkage credential",
+              arguments: {
+                $ref: "#/components/schemas/IIssueDomainLinkageCredentialArgs"
+              },
+              returnType: "object"
+            },
+            removeCredentialIssuance: {
+              description: "Removes a registered callback",
+              arguments: {
+                $ref: "#/components/schemas/IRemoveCredentialIssuanceArgs"
+              },
+              returnType: "boolean"
+            },
+            saveDidConfigurationResource: {
+              description: "Saves a DID configuration resource to the database",
+              arguments: {
+                $ref: "#/components/schemas/ISaveDidConfigurationResourceArgs"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/entities/DidConfigurationResourceEntity.ts
+import { Credential, Identifier, Claim } from "@veramo/data-store";
+import { asArray, computeEntryHash, extractIssuer } from "@veramo/utils";
+import { Entity, Column, PrimaryColumn, CreateDateColumn, UpdateDateColumn, ManyToMany, JoinTable, BaseEntity } from "typeorm";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var DidConfigurationResourceEntity = class extends BaseEntity {
+  static {
+    __name(this, "DidConfigurationResourceEntity");
+  }
+  origin;
+  context;
+  // TODO cascade of delete should be true when the VC is only attached to one DID configuration resource
+  linkedDids;
+  createdAt;
+  lastUpdatedAt;
+};
+_ts_decorate([
+  PrimaryColumn({
+    nullable: false
+  }),
+  _ts_metadata("design:type", String)
+], DidConfigurationResourceEntity.prototype, "origin", void 0);
+_ts_decorate([
+  Column({
+    nullable: false
+  }),
+  _ts_metadata("design:type", String)
+], DidConfigurationResourceEntity.prototype, "context", void 0);
+_ts_decorate([
+  ManyToMany(() => Credential, (credential) => credential.hash, {
+    nullable: false,
+    cascade: true,
+    onDelete: "NO ACTION"
+  }),
+  JoinTable({
+    name: "DidConfigurationResourceCredentials"
+  }),
+  _ts_metadata("design:type", typeof Array === "undefined" ? Object : Array)
+], DidConfigurationResourceEntity.prototype, "linkedDids", void 0);
+_ts_decorate([
+  CreateDateColumn({
+    name: "created_at",
+    nullable: false
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], DidConfigurationResourceEntity.prototype, "createdAt", void 0);
+_ts_decorate([
+  UpdateDateColumn({
+    name: "last_updated_at",
+    nullable: false
+  }),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], DidConfigurationResourceEntity.prototype, "lastUpdatedAt", void 0);
+DidConfigurationResourceEntity = _ts_decorate([
+  Entity("DidConfigurationResource")
+], DidConfigurationResourceEntity);
+var didConfigurationResourceFrom = /* @__PURE__ */ __name((didConfigurationResource) => {
+  return {
+    "@context": didConfigurationResource.context,
+    linked_dids: linkedDidsFrom(didConfigurationResource.linkedDids)
+  };
+}, "didConfigurationResourceFrom");
+var linkedDidsFrom = /* @__PURE__ */ __name((credentials) => {
+  return credentials.map((credential) => credential?.raw?.proof?.type === "JwtProof2020" && typeof credential?.raw?.proof?.jwt === "string" ? credential.raw.proof.jwt : credential.raw);
+}, "linkedDidsFrom");
+var createCredentialEntity = /* @__PURE__ */ __name((vci) => {
+  const vc = vci;
+  const credential = new Credential();
+  credential.context = asArray(vc["@context"]);
+  credential.type = asArray(vc.type || []);
+  credential.id = vc.id;
+  if (vc.issuanceDate) {
+    credential.issuanceDate = new Date(vc.issuanceDate);
+  }
+  if (vc.expirationDate) {
+    credential.expirationDate = new Date(vc.expirationDate);
+  }
+  const issuer = new Identifier();
+  issuer.did = extractIssuer(vc);
+  credential.issuer = issuer;
+  if (vc.credentialSubject.id) {
+    const subject = new Identifier();
+    subject.did = vc.credentialSubject.id;
+    credential.subject = subject;
+  }
+  credential.claims = [];
+  for (const type in vc.credentialSubject) {
+    if (vc.credentialSubject.hasOwnProperty(type)) {
+      const value = vc.credentialSubject[type];
+      if (type !== "id") {
+        const isObj = typeof value === "function" || typeof value === "object" && !!value;
+        const claim = new Claim();
+        claim.hash = computeEntryHash(JSON.stringify(vc) + type);
+        claim.type = type;
+        claim.value = isObj ? JSON.stringify(value) : value;
+        claim.isObj = isObj;
+        claim.issuer = credential.issuer;
+        claim.subject = credential.subject;
+        claim.expirationDate = credential.expirationDate;
+        claim.issuanceDate = credential.issuanceDate;
+        claim.credentialType = credential.type;
+        claim.context = credential.context;
+        credential.claims.push(claim);
+      }
+    }
+  }
+  credential.raw = vci;
+  return credential;
+}, "createCredentialEntity");
+
+// src/agent/WellKnownDidIssuer.ts
+import { CredentialCorrelationType, CredentialRole } from "@sphereon/ssi-sdk.credential-store";
+import { CredentialMapper, parseDid } from "@sphereon/ssi-types";
+import { ServiceTypesEnum, WellKnownDidIssuer as Issuer } from "@sphereon/wellknown-dids-client";
+import { normalizeCredential } from "did-jwt-vc";
+import { v4 as uuidv4 } from "uuid";
+import { RegulationType } from "@sphereon/ssi-sdk.data-store";
+var WellKnownDidIssuer = class {
+  static {
+    __name(this, "WellKnownDidIssuer");
+  }
+  dbConnection;
+  schema;
+  methods;
+  credentialIssuances;
+  didConfigurationResourceRelations;
+  constructor(dbConnection, args) {
+    this.dbConnection = dbConnection;
+    this.schema = schema.IWellKnownDidVerifier;
+    this.methods = {
+      addLinkedDomainsService: this.addLinkedDomainsService.bind(this),
+      getDidConfigurationResource: this.getDidConfigurationResource.bind(this),
+      issueDidConfigurationResource: this.issueDidConfigurationResource.bind(this),
+      issueDomainLinkageCredential: this.issueDomainLinkageCredential.bind(this),
+      registerCredentialIssuance: this.registerCredentialIssuance.bind(this),
+      removeCredentialIssuance: this.removeCredentialIssuance.bind(this),
+      saveDidConfigurationResource: this.saveDidConfigurationResource.bind(this)
+    };
+    this.didConfigurationResourceRelations = [
+      "linkedDids"
+    ];
+    this.credentialIssuances = args && args.credentialIssuances || {};
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.registerSignatureVerification} */
+  async registerCredentialIssuance(args, context) {
+    if (this.credentialIssuances[args.callbackName] !== void 0) {
+      return Promise.reject(new Error(`Credential issuance with callbackName: ${args.callbackName} already present`));
+    }
+    this.credentialIssuances[args.callbackName] = args.credentialIssuance;
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.removeSignatureVerification} */
+  async removeCredentialIssuance(args, context) {
+    return delete this.credentialIssuances[args.callbackName];
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.issueDidConfigurationResource} */
+  async issueDidConfigurationResource(args, context) {
+    if (!args.issuances.every((issuance) => issuance.origin === args.issuances[0].origin)) {
+      return Promise.reject(Error("All verifiableCredentials should be issued for the same origin"));
+    }
+    const addServices = args.issuances.map((issuance) => this.addLinkedDomainsService({
+      did: issuance.did,
+      origin: issuance.origin,
+      serviceId: issuance.serviceId
+    }, context));
+    return Promise.all(addServices).then(async () => new Issuer().issueDidConfigurationResource({
+      issuances: await this.mapIssuances(args.issuances),
+      issueCallback: typeof args.credentialIssuance === "string" ? await this.getCredentialIssuance(args.credentialIssuance) : args.credentialIssuance
+    }).then(async (didConfigurationResource) => {
+      if (args.save) {
+        await this.saveDidConfigurationResource({
+          origin: args.issuances[0].origin,
+          didConfigurationResource
+        }, context);
+      }
+      return didConfigurationResource;
+    }).catch((error) => Promise.reject(Error(`Unable to issue DID configuration resource. Error: ${error.message}`))));
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.saveDidConfigurationResource} */
+  async saveDidConfigurationResource(args, context) {
+    const didConfigurationEntity = {
+      origin: args.origin,
+      context: args.didConfigurationResource["@context"],
+      linkedDids: args.didConfigurationResource.linked_dids.map((credential) => createCredentialEntity(this.normalizeCredential(credential)))
+    };
+    await (await this.dbConnection).getRepository(DidConfigurationResourceEntity).save(didConfigurationEntity, {
+      transaction: true
+    });
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.getDidConfigurationResource} */
+  async getDidConfigurationResource(args, context) {
+    const result = await (await this.dbConnection).getRepository(DidConfigurationResourceEntity).findOne({
+      where: {
+        origin: args.origin
+      },
+      relations: this.didConfigurationResourceRelations
+    });
+    if (!result) {
+      return Promise.reject(Error(`No DID configuration resource found for origin: ${args.origin}`));
+    }
+    return didConfigurationResourceFrom(result);
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.issueDomainLinkageCredential} */
+  async issueDomainLinkageCredential(args, context) {
+    const did = parseDid(args.did).did;
+    if (new URL(args.origin).origin !== args.origin) {
+      return Promise.reject(Error(`Origin ${args.origin} is not valid`));
+    }
+    if (new URL(args.origin).protocol !== "https:") {
+      return Promise.reject(Error(`Origin ${args.origin} is not a https URL`));
+    }
+    if (args.issuanceDate && isNaN(Date.parse(args.issuanceDate))) {
+      return Promise.reject(Error(`IssuanceDate ${args.issuanceDate} is not a valid date`));
+    }
+    if (isNaN(Date.parse(args.expirationDate))) {
+      return Promise.reject(Error(`ExpirationDate ${args.expirationDate} is not a valid date`));
+    }
+    const credentialIssuance = typeof args.credentialIssuance === "string" ? await this.getCredentialIssuance(args.credentialIssuance) : args.credentialIssuance;
+    return new Issuer().issueDomainLinkageCredential({
+      did,
+      origin: args.origin,
+      issuanceDate: args.issuanceDate,
+      expirationDate: args.expirationDate,
+      options: args.options,
+      issueCallback: credentialIssuance
+    }).then(async (credential) => {
+      if (args.save) {
+        await this.saveDomainLinkageCredential(credential, context);
+      }
+      return credential;
+    }).catch((error) => Promise.reject(Error(`Unable to issue domain linkage credential for DID: ${did}. Error: ${error.message}`)));
+  }
+  /** {@inheritDoc IWellKnownDidIssuer.addLinkedDomainsService} */
+  async addLinkedDomainsService(args, context) {
+    const did = parseDid(args.did).did;
+    if (new URL(args.origin).origin !== args.origin) {
+      return Promise.reject(Error(`Origin ${args.origin} is not valid`));
+    }
+    if (new URL(args.origin).protocol !== "https:") {
+      return Promise.reject(Error(`Origin ${args.origin} is not a https URL`));
+    }
+    context.agent.didManagerGet({
+      did
+    }).catch(() => Promise.reject(Error("DID cannot be found"))).then(async (identifier) => {
+      if (!identifier.services || identifier.services.filter(
+        // TODO we should also check for the origins in the serviceEndpoint objects when we start supporting multiple origins
+        (service) => service.type === ServiceTypesEnum.LINKED_DOMAINS && service.serviceEndpoint === args.origin
+      ).length === 0) {
+        await context.agent.didManagerAddService({
+          did: identifier.did,
+          service: {
+            id: args.serviceId || uuidv4(),
+            type: ServiceTypesEnum.LINKED_DOMAINS,
+            // TODO We should support a serviceEndpoint object here when we update to Veramo 3.1.6.next-165 or higher, as then we can support multiple origins
+            serviceEndpoint: args.origin
+          }
+        });
+      }
+    }).catch((error) => Promise.reject(Error(`Unable to add LinkedDomains service to DID: ${args.did}. Error: ${error.message}`)));
+  }
+  async getCredentialIssuance(callbackName) {
+    if (this.credentialIssuances[callbackName] === void 0) {
+      return Promise.reject(new Error(`Credential issuance not found for callbackName: ${callbackName}`));
+    }
+    return this.credentialIssuances[callbackName];
+  }
+  async saveDomainLinkageCredential(credential, context) {
+    const vc = this.normalizeCredential(credential);
+    return context.agent.crsAddCredential({
+      credential: {
+        rawDocument: JSON.stringify(vc),
+        credentialRole: CredentialRole.ISSUER,
+        regulationType: RegulationType.NON_REGULATED,
+        kmsKeyRef: "FIXME",
+        identifierMethod: "did",
+        issuerCorrelationId: CredentialMapper.issuerCorrelationIdFromIssuerType(vc.issuer),
+        issuerCorrelationType: CredentialCorrelationType.DID,
+        subjectCorrelationId: CredentialMapper.issuerCorrelationIdFromIssuerType(vc.issuer),
+        subjectCorrelationType: CredentialCorrelationType.DID
+      }
+    });
+  }
+  normalizeCredential(credential) {
+    return typeof credential === "string" ? normalizeCredential(credential) : credential;
+  }
+  async mapIssuances(issuances) {
+    const promises = issuances.map(async (issuance) => {
+      return {
+        ...issuance,
+        issueCallback: typeof issuance.credentialIssuance === "string" ? await this.getCredentialIssuance(issuance.credentialIssuance) : issuance.credentialIssuance
+      };
+    });
+    return Promise.all(promises);
+  }
+};
+
+// src/migrations/generic/1-CreateWellknownDidIssuer.ts
+import Debug from "debug";
+
+// src/migrations/postgres/1661165115000-CreateWellknownDidIssuer.ts
+var CreateWellknownDidIssuer1661165115000 = class {
+  static {
+    __name(this, "CreateWellknownDidIssuer1661165115000");
+  }
+  name = "CreateWellknownDidIssuer1661165115000";
+  async up(queryRunner) {
+    await queryRunner.query(`CREATE TABLE "DidConfigurationResource" ("origin" varchar NOT NULL, "context" varchar NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), "last_updated_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_Origin" PRIMARY KEY ("origin"))`);
+    await queryRunner.query(`CREATE TABLE "DidConfigurationResourceCredentials" ("didConfigurationResourceOrigin" varchar NOT NULL, "credentialHash" varchar NOT NULL)`);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(`DROP TABLE "DidConfigurationResource"`);
+    await queryRunner.query(`DROP TABLE "DidConfigurationResourceCredentials"`);
+  }
+};
+
+// src/migrations/sqlite/1661161799000-CreateWellknownDidIssuer.ts
+var CreateWellknownDidIssuer1661161799000 = class {
+  static {
+    __name(this, "CreateWellknownDidIssuer1661161799000");
+  }
+  name = "CreateWellknownDidIssuer1661161799000";
+  async up(queryRunner) {
+    await queryRunner.query(`CREATE TABLE "DidConfigurationResource" ("origin" varchar PRIMARY KEY NOT NULL, "context" varchar NOT NULL, "created_at" datetime NOT NULL DEFAULT (datetime('now')), "last_updated_at" datetime NOT NULL DEFAULT (datetime('now')))`);
+    await queryRunner.query(`CREATE TABLE "DidConfigurationResourceCredentials" ("didConfigurationResourceOrigin" varchar NOT NULL, "credentialHash" varchar NOT NULL)`);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(`DROP TABLE "DidConfigurationResource"`);
+    await queryRunner.query(`DROP TABLE "DidConfigurationResourceCredentials"`);
+  }
+};
+
+// src/migrations/generic/1-CreateWellknownDidIssuer.ts
+var debug = Debug("sphereon:ssi-sdk:migrations");
+var CreateWellknownDidIssuer1661162010000 = class {
+  static {
+    __name(this, "CreateWellknownDidIssuer1661162010000");
+  }
+  name = "CreateWellknownDidIssuer1661162010000";
+  async up(queryRunner) {
+    debug("migration: creating well-known DID tables");
+    const dbType = queryRunner.connection.driver.options.type;
+    if (dbType === "postgres") {
+      debug("using postgres migration file");
+      const mig = new CreateWellknownDidIssuer1661165115000();
+      const up = await mig.up(queryRunner);
+      debug("Migration statements executed");
+      return up;
+    } else if (dbType === "sqlite" || dbType === "react-native" || dbType === "expo") {
+      debug("using sqlite/react-native migration file");
+      const mig = new CreateWellknownDidIssuer1661161799000();
+      const up = await mig.up(queryRunner);
+      debug("Migration statements executed");
+      return up;
+    } else {
+      return Promise.reject(`Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`);
+    }
+  }
+  async down(queryRunner) {
+    debug("reverting well-known DID tables");
+    const dbType = queryRunner.connection.driver.options.type;
+    if (dbType === "postgres") {
+      debug("using postgres migration file");
+      const mig = new CreateWellknownDidIssuer1661165115000();
+      const down = await mig.down(queryRunner);
+      debug("Migration statements executed");
+      return down;
+    } else if (dbType === "sqlite" || dbType === "react-native" || dbType === "expo") {
+      debug("using sqlite/react-native migration file");
+      const mig = new CreateWellknownDidIssuer1661161799000();
+      const down = await mig.down(queryRunner);
+      debug("Migration statements executed");
+      return down;
+    } else {
+      return Promise.reject(`Migrations are currently only supported for sqlite, react-native, expor and postgres. Was ${dbType}. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now`);
+    }
+  }
+};
+
+// src/migrations/generic/index.ts
+var WellknownDidIssuerMigrations = [
+  CreateWellknownDidIssuer1661162010000
+];
+
+// src/index.ts
+var schema = require_plugin_schema();
+var WellknownDidIssuerEntities = [
+  DidConfigurationResourceEntity
+];
+export {
+  DidConfigurationResourceEntity,
+  WellKnownDidIssuer,
+  WellknownDidIssuerEntities,
+  WellknownDidIssuerMigrations,
+  schema
+};
 //# sourceMappingURL=index.js.map