@sphereon/ssi-sdk.contact-manager 0.33.1-next.3 → 0.33.1-next.68

package/dist/index.cjs

@@ -0,0 +1,961 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module2) {
+    module2.exports = {
+      IContactManager: {
+        components: {
+          schemas: {
+            IGetContactArgs: {
+              type: "object",
+              properties: {
+                contactId: {
+                  type: "string"
+                }
+              },
+              required: ["contactId"]
+            },
+            IGetContactsArgs: {
+              type: "object",
+              properties: {
+                filter: {
+                  type: "array",
+                  items: {
+                    type: "object"
+                  }
+                }
+              }
+            },
+            IAddContactArgs: {
+              type: "object",
+              properties: {
+                contact: {
+                  $ref: "#/components/schemas/IBasicContact"
+                }
+              },
+              required: ["party"]
+            },
+            IRemoveContactArgs: {
+              type: "object",
+              properties: {
+                contactId: {
+                  type: "string"
+                }
+              },
+              required: ["contactId"]
+            },
+            IUpdateContactArgs: {
+              type: "object",
+              properties: {
+                contact: {
+                  $ref: "#/components/schemas/IBasicContact"
+                }
+              },
+              required: ["party"]
+            },
+            IGetIdentityArgs: {
+              type: "object",
+              properties: {
+                identityId: {
+                  type: "string"
+                }
+              },
+              required: ["identityId"]
+            },
+            IGetIdentitiesArgs: {
+              type: "object",
+              properties: {
+                contactId: {
+                  type: "string"
+                }
+              },
+              required: ["contactId"]
+            },
+            IAddIdentityArgs: {
+              type: "object",
+              properties: {
+                identity: {
+                  $ref: "#/components/schemas/IIdentity"
+                }
+              },
+              required: ["identity"]
+            },
+            IRemoveIdentityArgs: {
+              type: "object",
+              properties: {
+                identityId: {
+                  type: "string"
+                }
+              },
+              required: ["identityId"]
+            },
+            IUpdateIdentityArgs: {
+              type: "object",
+              properties: {
+                identity: {
+                  $ref: "#/components/schemas/IIdentity"
+                }
+              },
+              required: ["identity"]
+            },
+            IBasicContact: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string"
+                },
+                alias: {
+                  type: "string"
+                },
+                uri: {
+                  type: "string"
+                },
+                identities: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IBasicIdentity"
+                  }
+                }
+              },
+              required: ["name", "alias"]
+            },
+            IContact: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                alias: {
+                  type: "string"
+                },
+                uri: {
+                  type: "string"
+                },
+                identities: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IIdentity"
+                  }
+                },
+                createdAt: {
+                  type: "string",
+                  format: "date-time"
+                },
+                lastUpdatedAt: {
+                  type: "string",
+                  format: "date-time"
+                }
+              },
+              required: ["id", "name", "alias", "createdAt", "lastUpdatedAt"]
+            },
+            IMetadataItem: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                label: {
+                  type: "string"
+                },
+                value: {
+                  type: "string"
+                }
+              },
+              required: ["id", "label", "value"]
+            },
+            BasicMetadataItem: {
+              type: "object",
+              properties: {
+                label: {
+                  type: "string"
+                },
+                value: {
+                  type: "string"
+                }
+              },
+              required: ["label", "value"]
+            },
+            IBasicIdentity: {
+              type: "object",
+              properties: {
+                alias: {
+                  type: "string"
+                },
+                identifier: {
+                  $ref: "#/components/schemas/BasicCorrelationIdentifier"
+                },
+                connection: {
+                  $ref: "#/components/schemas/IBasicConnection"
+                },
+                metadata: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IMetadataItem"
+                  }
+                },
+                createdAt: {
+                  type: "string",
+                  format: "date-time"
+                },
+                lastUpdatedAt: {
+                  type: "string",
+                  format: "date-time"
+                }
+              },
+              required: ["id", "alias", "identifier", "createdAt", "lastUpdatedAt"]
+            },
+            IIdentity: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                alias: {
+                  type: "string"
+                },
+                identifier: {
+                  $ref: "#/components/schemas/ICorrelationIdentifier"
+                },
+                connection: {
+                  $ref: "#/components/schemas/IConnection"
+                },
+                metadata: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IMetadataItem"
+                  }
+                },
+                createdAt: {
+                  type: "string",
+                  format: "date-time"
+                },
+                lastUpdatedAt: {
+                  type: "string",
+                  format: "date-time"
+                }
+              },
+              required: ["id", "alias", "identifier", "createdAt", "lastUpdatedAt"]
+            },
+            CorrelationIdentifierEnum: {
+              type: "string",
+              enum: ["did", "url"]
+            },
+            BasicCorrelationIdentifier: {
+              type: "object",
+              properties: {
+                type: {
+                  $ref: "#/components/schemas/CorrelationIdentifierEnum"
+                },
+                correlationId: {
+                  type: "string"
+                }
+              },
+              required: ["type", "correlationId"]
+            },
+            ICorrelationIdentifier: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                type: {
+                  $ref: "#/components/schemas/CorrelationIdentifierEnum"
+                },
+                correlationId: {
+                  type: "string"
+                }
+              },
+              required: ["id", "type", "correlationId"]
+            },
+            ConnectionTypeEnum: {
+              type: "string",
+              enum: ["openid", "didauth", "siopv2+oidc4vp"]
+            },
+            IBasicConnection: {
+              type: "object",
+              properties: {
+                type: {
+                  $ref: "#/components/schemas/ConnectionTypeEnum"
+                },
+                config: {
+                  $ref: "#/components/schemas/BasicConnectionConfig"
+                }
+              },
+              required: ["type", "config"]
+            },
+            IConnection: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                type: {
+                  $ref: "#/components/schemas/ConnectionTypeEnum"
+                },
+                config: {
+                  $ref: "#/components/schemas/ConnectionConfig"
+                }
+              },
+              required: ["id", "type", "config"]
+            },
+            BasicConnectionConfig: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/BasicDidAuthConfig"
+                },
+                {
+                  $ref: "#/components/schemas/BasicOpenIdConfig"
+                }
+              ]
+            },
+            ConnectionConfig: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/IOpenIdConfig"
+                },
+                {
+                  $ref: "#/components/schemas/IDidAuthConfig"
+                }
+              ]
+            },
+            BasicDidAuthConfig: {
+              type: "object",
+              properties: {
+                identifier: {
+                  $ref: "#/components/schemas/IIdentifier"
+                },
+                stateId: {
+                  type: "string"
+                },
+                redirectUrl: {
+                  type: "string"
+                },
+                sessionId: {
+                  type: "string"
+                }
+              },
+              required: ["identifier", "stateId", "redirectUrl", "sessionId"]
+            },
+            BasicOpenIdConfig: {
+              type: "object",
+              properties: {
+                clientId: {
+                  type: "string"
+                },
+                clientSecret: {
+                  type: "string"
+                },
+                scopes: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                issuer: {
+                  type: "string"
+                },
+                redirectUrl: {
+                  type: "string"
+                },
+                dangerouslyAllowInsecureHttpRequests: {
+                  type: "boolean"
+                },
+                clientAuthMethod: {
+                  type: "string",
+                  enum: ["basic", "post"]
+                }
+              },
+              required: ["clientId", "clientSecret", "scopes", "issuer", "redirectUrl", "dangerouslyAllowInsecureHttpRequests"]
+            },
+            IOpenIdConfig: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                clientId: {
+                  type: "string"
+                },
+                clientSecret: {
+                  type: "string"
+                },
+                scopes: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                issuer: {
+                  type: "string"
+                },
+                redirectUrl: {
+                  type: "string"
+                },
+                dangerouslyAllowInsecureHttpRequests: {
+                  type: "boolean"
+                },
+                clientAuthMethod: {
+                  type: "string",
+                  enum: ["basic", "post"]
+                }
+              },
+              required: ["id", "clientId", "clientSecret", "scopes", "issuer", "redirectUrl", "dangerouslyAllowInsecureHttpRequests"]
+            },
+            IDidAuthConfig: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                identifier: {
+                  $ref: "#/components/schemas/IIdentifier"
+                },
+                stateId: {
+                  type: "string"
+                },
+                redirectUrl: {
+                  type: "string"
+                },
+                sessionId: {
+                  type: "string"
+                }
+              },
+              required: ["id", "identifier", "stateId", "redirectUrl", "sessionId"]
+            },
+            IIdentifier: {
+              type: "object",
+              properties: {
+                did: {
+                  type: "string",
+                  description: "Decentralized identifier"
+                },
+                alias: {
+                  type: "string",
+                  description: "Optional. Identifier alias. Can be used to reference an object in an external system"
+                },
+                provider: {
+                  type: "string",
+                  description: "Identifier provider name"
+                },
+                controllerKeyId: {
+                  type: "string",
+                  description: "Controller key id"
+                },
+                keys: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IKey"
+                  },
+                  description: "Array of managed keys"
+                },
+                services: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IService"
+                  },
+                  description: "Array of services"
+                }
+              },
+              required: ["did", "provider", "keys", "services"],
+              description: "Identifier interface"
+            },
+            IKey: {
+              type: "object",
+              properties: {
+                kid: {
+                  type: "string",
+                  description: "Key ID"
+                },
+                kms: {
+                  type: "string",
+                  description: "Key Management System"
+                },
+                type: {
+                  $ref: "#/components/schemas/TKeyType",
+                  description: "Key type"
+                },
+                publicKeyHex: {
+                  type: "string",
+                  description: "Public key"
+                },
+                privateKeyHex: {
+                  type: "string",
+                  description: "Optional. Private key"
+                },
+                meta: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/KeyMetadata"
+                    },
+                    {
+                      type: "null"
+                    }
+                  ],
+                  description: "Optional. Key metadata. This should be used to determine which algorithms are supported."
+                }
+              },
+              required: ["kid", "kms", "type", "publicKeyHex"],
+              description: "Cryptographic key"
+            },
+            TKeyType: {
+              type: "string",
+              enum: ["Ed25519", "Secp256k1", "Secp256r1", "X25519", "Bls12381G1", "Bls12381G2", "RSA"],
+              description: "Cryptographic key type."
+            },
+            KeyMetadata: {
+              type: "object",
+              properties: {
+                algorithms: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              description: "This encapsulates data about a key.\n\nImplementations of  {@link  @veramo/key-manager#AbstractKeyManagementSystem | AbstractKeyManagementSystem }  should populate this object, for each key, with the algorithms that can be performed using it.\n\nThis can also be used to add various tags to the keys under management."
+            },
+            IService: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  description: "ID"
+                },
+                type: {
+                  type: "string",
+                  description: "Service type"
+                },
+                serviceEndpoint: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/IServiceEndpoint"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/IServiceEndpoint"
+                      }
+                    }
+                  ],
+                  description: "Endpoint URL"
+                },
+                description: {
+                  type: "string",
+                  description: "Optional. Description"
+                }
+              },
+              required: ["id", "type", "serviceEndpoint"],
+              description: "Identifier service"
+            },
+            IServiceEndpoint: {
+              anyOf: [
+                {
+                  type: "string"
+                },
+                {
+                  type: "object"
+                }
+              ],
+              description: "Represents a service endpoint URL or a map of URLs"
+            }
+          },
+          methods: {
+            cmGetContact: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IGetContactArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IContact"
+              }
+            },
+            cmGetContacts: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IGetContactsArgs"
+              },
+              returnType: {
+                type: "array",
+                items: {
+                  $ref: "#/components/schemas/IContact"
+                }
+              }
+            },
+            cmAddContact: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IAddContactArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IContact"
+              }
+            },
+            cmRemoveContact: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IRemoveContactArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            cmUpdateContact: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IUpdateContactArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IContact"
+              }
+            },
+            cmGetIdentity: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IGetIdentityArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IIdentity"
+              }
+            },
+            cmGetIdentities: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IGetIdentitiesArgs"
+              },
+              returnType: {
+                type: "array",
+                items: {
+                  $ref: "#/components/schemas/IIdentity"
+                }
+              }
+            },
+            cmAddIdentity: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IAddIdentityArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IIdentity"
+              }
+            },
+            cmRemoveIdentity: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IRemoveIdentityArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            cmUpdateIdentity: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IUpdateConnectionArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IIdentity"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ContactManager: () => ContactManager,
+  contactManagerMethods: () => contactManagerMethods,
+  contextHasContactManager: () => contextHasContactManager,
+  schema: () => schema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent/ContactManager.ts
+var import_ssi_sdk = require("@sphereon/ssi-sdk.data-store");
+var contactManagerMethods = [
+  "cmGetContact",
+  "cmGetContacts",
+  "cmAddContact",
+  "cmUpdateContact",
+  "cmRemoveContact",
+  "cmGetIdentity",
+  "cmGetIdentities",
+  "cmAddIdentity",
+  "cmUpdateIdentity",
+  "cmRemoveIdentity",
+  "cmAddRelationship",
+  "cmRemoveRelationship",
+  "cmGetRelationship",
+  "cmGetRelationships",
+  "cmUpdateRelationship",
+  "cmGetContactType",
+  "cmGetContactTypes",
+  "cmAddContactType",
+  "cmUpdateContactType",
+  "cmRemoveContactType",
+  "cmGetElectronicAddress",
+  "cmGetElectronicAddresses",
+  "cmAddElectronicAddress",
+  "cmUpdateElectronicAddress",
+  "cmRemoveElectronicAddress",
+  "cmGetPhysicalAddress",
+  "cmGetPhysicalAddresses",
+  "cmAddPhysicalAddress",
+  "cmUpdatePhysicalAddress",
+  "cmRemovePhysicalAddress"
+];
+var ContactManager = class {
+  static {
+    __name(this, "ContactManager");
+  }
+  schema = schema.IContactManager;
+  methods = {
+    cmGetContact: this.cmGetContact.bind(this),
+    cmGetContacts: this.cmGetContacts.bind(this),
+    cmAddContact: this.cmAddContact.bind(this),
+    cmUpdateContact: this.cmUpdateContact.bind(this),
+    cmRemoveContact: this.cmRemoveContact.bind(this),
+    cmGetIdentity: this.cmGetIdentity.bind(this),
+    cmGetIdentities: this.cmGetIdentities.bind(this),
+    cmAddIdentity: this.cmAddIdentity.bind(this),
+    cmUpdateIdentity: this.cmUpdateIdentity.bind(this),
+    cmRemoveIdentity: this.cmRemoveIdentity.bind(this),
+    cmAddRelationship: this.cmAddRelationship.bind(this),
+    cmRemoveRelationship: this.cmRemoveRelationship.bind(this),
+    cmGetRelationship: this.cmGetRelationship.bind(this),
+    cmGetRelationships: this.cmGetRelationships.bind(this),
+    cmUpdateRelationship: this.cmUpdateRelationship.bind(this),
+    cmGetContactType: this.cmGetContactType.bind(this),
+    cmGetContactTypes: this.cmGetContactTypes.bind(this),
+    cmAddContactType: this.cmAddContactType.bind(this),
+    cmUpdateContactType: this.cmUpdateContactType.bind(this),
+    cmRemoveContactType: this.cmRemoveContactType.bind(this),
+    cmGetElectronicAddress: this.cmGetElectronicAddress.bind(this),
+    cmGetElectronicAddresses: this.cmGetElectronicAddresses.bind(this),
+    cmAddElectronicAddress: this.cmAddElectronicAddress.bind(this),
+    cmUpdateElectronicAddress: this.cmUpdateElectronicAddress.bind(this),
+    cmRemoveElectronicAddress: this.cmRemoveElectronicAddress.bind(this),
+    cmGetPhysicalAddress: this.cmGetPhysicalAddress.bind(this),
+    cmGetPhysicalAddresses: this.cmGetPhysicalAddresses.bind(this),
+    cmAddPhysicalAddress: this.cmAddPhysicalAddress.bind(this),
+    cmUpdatePhysicalAddress: this.cmUpdatePhysicalAddress.bind(this),
+    cmRemovePhysicalAddress: this.cmRemovePhysicalAddress.bind(this)
+  };
+  store;
+  constructor(options) {
+    this.store = options.store;
+  }
+  /** {@inheritDoc IContactManager.cmGetContact} */
+  async cmGetContact(args, context) {
+    const { contactId } = args;
+    return this.store.getParty({
+      partyId: contactId
+    });
+  }
+  /** {@inheritDoc IContactManager.cmGetContacts} */
+  async cmGetContacts(args) {
+    return this.store.getParties(args);
+  }
+  /** {@inheritDoc IContactManager.cmAddContact} */
+  async cmAddContact(args, context) {
+    const { uri, contactType, identities, electronicAddresses, physicalAddresses } = args;
+    return this.store.addParty({
+      uri,
+      partyType: contactType,
+      contact: this.getContactInformationFrom(args),
+      identities,
+      electronicAddresses,
+      physicalAddresses
+    });
+  }
+  /** {@inheritDoc IContactManager.cmUpdateContact} */
+  async cmUpdateContact(args, context) {
+    const { contact } = args;
+    return this.store.updateParty({
+      party: contact
+    });
+  }
+  /** {@inheritDoc IContactManager.cmRemoveContact} */
+  async cmRemoveContact(args, context) {
+    const { contactId } = args;
+    return this.store.removeParty({
+      partyId: contactId
+    }).then(() => true);
+  }
+  /** {@inheritDoc IContactManager.cmGetIdentity} */
+  async cmGetIdentity(args, context) {
+    return this.store.getIdentity(args);
+  }
+  /** {@inheritDoc IContactManager.cmGetIdentities} */
+  async cmGetIdentities(args) {
+    return this.store.getIdentities(args);
+  }
+  /** {@inheritDoc IContactManager.cmAddIdentity} */
+  async cmAddIdentity(args, context) {
+    const { contactId, identity } = args;
+    return this.store.addIdentity({
+      partyId: contactId,
+      identity
+    });
+  }
+  /** {@inheritDoc IContactManager.cmUpdateIdentity} */
+  async cmUpdateIdentity(args, context) {
+    return this.store.updateIdentity(args);
+  }
+  /** {@inheritDoc IContactManager.cmRemoveIdentity} */
+  async cmRemoveIdentity(args, context) {
+    return this.store.removeIdentity(args).then(() => true);
+  }
+  /** {@inheritDoc IContactManager.cmAddRelationship} */
+  async cmAddRelationship(args, context) {
+    return this.store.addRelationship(args);
+  }
+  /** {@inheritDoc IContactManager.cmRemoveRelationship} */
+  async cmRemoveRelationship(args, context) {
+    return this.store.removeRelationship(args).then(() => true);
+  }
+  /** {@inheritDoc IContactManager.cmGetRelationship} */
+  async cmGetRelationship(args, context) {
+    return this.store.getRelationship(args);
+  }
+  /** {@inheritDoc IContactManager.cmGetRelationships} */
+  async cmGetRelationships(args) {
+    return this.store.getRelationships(args);
+  }
+  /** {@inheritDoc IContactManager.cmUpdateRelationship} */
+  async cmUpdateRelationship(args, context) {
+    return this.store.updateRelationship(args);
+  }
+  /** {@inheritDoc IContactManager.cmGetContactType} */
+  async cmGetContactType(args, context) {
+    const { contactTypeId } = args;
+    return this.store.getPartyType({
+      partyTypeId: contactTypeId
+    });
+  }
+  /** {@inheritDoc IContactManager.cmGetContactTypes} */
+  async cmGetContactTypes(args) {
+    return this.store.getPartyTypes(args);
+  }
+  /** {@inheritDoc IContactManager.cmAddContactType} */
+  async cmAddContactType(args, context) {
+    return this.store.addPartyType(args);
+  }
+  /** {@inheritDoc IContactManager.cmUpdateContactType} */
+  async cmUpdateContactType(args, context) {
+    const { contactType } = args;
+    return this.store.updatePartyType({
+      partyType: contactType
+    });
+  }
+  /** {@inheritDoc IContactManager.cmRemoveContactType} */
+  async cmRemoveContactType(args, context) {
+    const { contactTypeId } = args;
+    return this.store.removePartyType({
+      partyTypeId: contactTypeId
+    }).then(() => true);
+  }
+  /** {@inheritDoc IContactManager.cmGetElectronicAddress} */
+  async cmGetElectronicAddress(args, context) {
+    return this.store.getElectronicAddress(args);
+  }
+  /** {@inheritDoc IContactManager.cmGetElectronicAddresses} */
+  async cmGetElectronicAddresses(args) {
+    return this.store.getElectronicAddresses(args);
+  }
+  /** {@inheritDoc IContactManager.cmAddElectronicAddress} */
+  async cmAddElectronicAddress(args) {
+    const { contactId, electronicAddress } = args;
+    return this.store.addElectronicAddress({
+      partyId: contactId,
+      electronicAddress
+    });
+  }
+  /** {@inheritDoc IContactManager.cmUpdateElectronicAddress} */
+  async cmUpdateElectronicAddress(args) {
+    return this.store.updateElectronicAddress(args);
+  }
+  /** {@inheritDoc IContactManager.cmRemoveElectronicAddress} */
+  async cmRemoveElectronicAddress(args) {
+    return this.store.removeElectronicAddress(args).then(() => true);
+  }
+  /** {@inheritDoc IContactManager.cmGetPhysicalAddress} */
+  async cmGetPhysicalAddress(args) {
+    return this.store.getPhysicalAddress(args);
+  }
+  /** {@inheritDoc IContactManager.cmGetPhysicalAddresses} */
+  async cmGetPhysicalAddresses(args) {
+    return this.store.getPhysicalAddresses(args);
+  }
+  /** {@inheritDoc IContactManager.cmAddPhysicalAddress} */
+  async cmAddPhysicalAddress(args) {
+    const { contactId, physicalAddress } = args;
+    return this.store.addPhysicalAddress({
+      partyId: contactId,
+      physicalAddress
+    });
+  }
+  /** {@inheritDoc IContactManager.cmUpdatePhysicalAddress} */
+  async cmUpdatePhysicalAddress(args) {
+    return this.store.updatePhysicalAddress(args);
+  }
+  /** {@inheritDoc IContactManager.cmRemovePhysicalAddress} */
+  async cmRemovePhysicalAddress(args) {
+    return this.store.removePhysicalAddress(args).then(() => true);
+  }
+  getContactInformationFrom(contact) {
+    if ((0, import_ssi_sdk.isNaturalPerson)(contact)) {
+      return {
+        firstName: contact.firstName,
+        middleName: contact.middleName,
+        lastName: contact.lastName,
+        displayName: contact.displayName
+      };
+    } else if ((0, import_ssi_sdk.isOrganization)(contact)) {
+      return {
+        legalName: contact.legalName,
+        displayName: contact.displayName
+      };
+    }
+    throw new Error("Contact not supported");
+  }
+};
+
+// src/types/IContactManager.ts
+var import_ssi_sdk2 = require("@sphereon/ssi-sdk.agent-config");
+function contextHasContactManager(context) {
+  return (0, import_ssi_sdk2.contextHasPlugin)(context, "cmGetContact");
+}
+__name(contextHasContactManager, "contextHasContactManager");
+
+// src/index.ts
+var schema = require_plugin_schema();
+//# sourceMappingURL=index.cjs.map