@sphereon/ssi-sdk.data-store/dist/index.js

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/entities/contact/BaseConfigEntity.ts
import typeorm6 from "typeorm";

// src/entities/contact/ConnectionEntity.ts
import typeorm5 from "typeorm";

// src/types/contact/contact.ts
var ConnectionType = /* @__PURE__ */ function(ConnectionType2) {
  ConnectionType2["OPENID_CONNECT"] = "OIDC";
  ConnectionType2["SIOPv2"] = "SIOPv2";
  ConnectionType2["SIOPv2_OpenID4VP"] = "SIOPv2+OpenID4VP";
  return ConnectionType2;
}({});
var CorrelationIdentifierType = /* @__PURE__ */ function(CorrelationIdentifierType2) {
  CorrelationIdentifierType2["DID"] = "did";
  CorrelationIdentifierType2["URL"] = "url";
  return CorrelationIdentifierType2;
}({});
var PartyTypeType = /* @__PURE__ */ function(PartyTypeType2) {
  PartyTypeType2["NATURAL_PERSON"] = "naturalPerson";
  PartyTypeType2["ORGANIZATION"] = "organization";
  return PartyTypeType2;
}({});
var PartyOrigin = /* @__PURE__ */ function(PartyOrigin2) {
  PartyOrigin2["INTERNAL"] = "INTERNAL";
  PartyOrigin2["EXTERNAL"] = "EXTERNAL";
  return PartyOrigin2;
}({});
var IdentityOrigin = /* @__PURE__ */ function(IdentityOrigin2) {
  IdentityOrigin2["INTERNAL"] = "INTERNAL";
  IdentityOrigin2["EXTERNAL"] = "EXTERNAL";
  return IdentityOrigin2;
}({});

// src/types/digitalCredential/enums.ts
var DocumentType = /* @__PURE__ */ function(DocumentType2) {
  DocumentType2["VC"] = "VC";
  DocumentType2["VP"] = "VP";
  DocumentType2["P"] = "P";
  DocumentType2["C"] = "C";
  return DocumentType2;
}({});
var RegulationType = /* @__PURE__ */ function(RegulationType2) {
  RegulationType2["PID"] = "PID";
  RegulationType2["QEAA"] = "QEAA";
  RegulationType2["EAA"] = "EAA";
  RegulationType2["NON_REGULATED"] = "NON_REGULATED";
  return RegulationType2;
}({});
var CredentialDocumentFormat = /* @__PURE__ */ function(CredentialDocumentFormat2) {
  CredentialDocumentFormat2["JSON_LD"] = "JSON_LD";
  CredentialDocumentFormat2["JWT"] = "JWT";
  CredentialDocumentFormat2["SD_JWT"] = "SD_JWT";
  CredentialDocumentFormat2["MSO_MDOC"] = "MSO_MDOC";
  return CredentialDocumentFormat2;
}({});
(function(CredentialDocumentFormat2) {
  function fromSpecValue(credentialFormat) {
    const format = credentialFormat.toLowerCase();
    if (format.includes("sd")) {
      return "SD_JWT";
    } else if (format.includes("ldp")) {
      return "JSON_LD";
    } else if (format.includes("mso") || credentialFormat.includes("mdoc")) {
      return "MSO_MDOC";
    } else if (format.includes("jwt_")) {
      return "JWT";
    } else {
      throw Error(`Could not map format ${format} to known format`);
    }
  }
  __name(fromSpecValue, "fromSpecValue");
  CredentialDocumentFormat2.fromSpecValue = fromSpecValue;
  function toSpecValue(documentFormat, documentType) {
    switch (documentFormat) {
      case "SD_JWT":
        return "vc+sd-jwt";
      case "MSO_MDOC":
        return "mso_mdoc";
      case "JSON_LD":
        return documentType === "C" || documentType === "VC" ? "ldp_vc" : "ldp_vp";
      case "JWT":
        return documentType === "C" || documentType === "VC" ? "jwt_vc_json" : "jwt_vp_json";
    }
  }
  __name(toSpecValue, "toSpecValue");
  CredentialDocumentFormat2.toSpecValue = toSpecValue;
})(CredentialDocumentFormat || (CredentialDocumentFormat = {}));
var CredentialCorrelationType = /* @__PURE__ */ function(CredentialCorrelationType2) {
  CredentialCorrelationType2["DID"] = "DID";
  CredentialCorrelationType2["X509_SAN"] = "X509_SAN";
  CredentialCorrelationType2["KID"] = "KID";
  CredentialCorrelationType2["URL"] = "URL";
  return CredentialCorrelationType2;
}({});
var CredentialRole = /* @__PURE__ */ function(CredentialRole2) {
  CredentialRole2["ISSUER"] = "ISSUER";
  CredentialRole2["VERIFIER"] = "VERIFIER";
  CredentialRole2["HOLDER"] = "HOLDER";
  CredentialRole2["FEDERATION_TRUST_ANCHOR"] = "FEDERATION_TRUST_ANCHOR";
  return CredentialRole2;
}({});
var CredentialStateType = /* @__PURE__ */ function(CredentialStateType2) {
  CredentialStateType2["REVOKED"] = "REVOKED";
  CredentialStateType2["VERIFIED"] = "VERIFIED";
  CredentialStateType2["EXPIRED"] = "EXPIRED";
  return CredentialStateType2;
}({});

// src/entities/contact/IdentityEntity.ts
import { BaseEntity as BaseEntity8, CreateDateColumn as CreateDateColumn7, Entity as Entity10, PrimaryGeneratedColumn as PrimaryGeneratedColumn10, UpdateDateColumn as UpdateDateColumn7, OneToOne as OneToOne4, JoinColumn as JoinColumn5, ManyToOne as ManyToOne7, Column as Column9, OneToMany as OneToMany4, BeforeInsert as BeforeInsert10, BeforeUpdate as BeforeUpdate10 } from "typeorm";
import { IsNotEmpty as IsNotEmpty7, validate as validate8 } from "class-validator";
import { typeOrmDateTime as typeOrmDateTime9 } from "@sphereon/ssi-sdk.agent-config";

// src/entities/contact/CorrelationIdentifierEntity.ts
import typeorm from "typeorm";
import { IsNotEmpty, validate } from "class-validator";

// src/utils/ValidatorUtils.ts
var getConstraint = /* @__PURE__ */ __name((validation) => {
  if (validation.children && validation.children.length > 0) {
    return getConstraint(validation.children[0]);
  } else {
    return validation.constraints;
  }
}, "getConstraint");

// src/entities/contact/CorrelationIdentifierEntity.ts
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 { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } = typeorm;
var CorrelationIdentifierEntity = class extends BaseEntity {
  static {
    __name(this, "CorrelationIdentifierEntity");
  }
  id;
  type;
  correlationId;
  ownerId;
  tenantId;
  identity;
  async validate() {
    const validation = await validate(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate([
  PrimaryGeneratedColumn("uuid"),
  _ts_metadata("design:type", String)
], CorrelationIdentifierEntity.prototype, "id", void 0);
_ts_decorate([
  Column("simple-enum", {
    name: "type",
    enum: CorrelationIdentifierType,
    nullable: false
  }),
  _ts_metadata("design:type", typeof CorrelationIdentifierType === "undefined" ? Object : CorrelationIdentifierType)
], CorrelationIdentifierEntity.prototype, "type", void 0);
_ts_decorate([
  Column("text", {
    name: "correlation_id",
    nullable: false,
    unique: true
  }),
  IsNotEmpty({
    message: "Blank correlation ids are not allowed"
  }),
  _ts_metadata("design:type", String)
], CorrelationIdentifierEntity.prototype, "correlationId", void 0);
_ts_decorate([
  Column("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata("design:type", String)
], CorrelationIdentifierEntity.prototype, "ownerId", void 0);
_ts_decorate([
  Column("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata("design:type", String)
], CorrelationIdentifierEntity.prototype, "tenantId", void 0);
_ts_decorate([
  OneToOne(() => IdentityEntity, (identity) => identity.identifier, {
    onDelete: "CASCADE"
  }),
  JoinColumn({
    name: "identity_id"
  }),
  _ts_metadata("design:type", typeof IdentityEntity === "undefined" ? Object : IdentityEntity)
], CorrelationIdentifierEntity.prototype, "identity", void 0);
_ts_decorate([
  BeforeInsert(),
  BeforeUpdate(),
  _ts_metadata("design:type", Function),
  _ts_metadata("design:paramtypes", []),
  _ts_metadata("design:returntype", Promise)
], CorrelationIdentifierEntity.prototype, "validate", null);
CorrelationIdentifierEntity = _ts_decorate([
  Entity("CorrelationIdentifier")
], CorrelationIdentifierEntity);

// src/entities/contact/IdentityMetadataItemEntity.ts
import { typeOrmDateTime } from "@sphereon/ssi-sdk.agent-config";
import { Entity as Entity2, Column as Column2, PrimaryGeneratedColumn as PrimaryGeneratedColumn2, BaseEntity as BaseEntity2, ManyToOne, BeforeInsert as BeforeInsert2, BeforeUpdate as BeforeUpdate2 } from "typeorm";
import { IsNotEmpty as IsNotEmpty2, validate as validate2 } from "class-validator";
function _ts_decorate2(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_decorate2, "_ts_decorate");
function _ts_metadata2(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata2, "_ts_metadata");
var IdentityMetadataItemEntity = class extends BaseEntity2 {
  static {
    __name(this, "IdentityMetadataItemEntity");
  }
  id;
  label;
  valueType;
  stringValue;
  numberValue;
  dateValue;
  boolValue;
  identity;
  async validate() {
    const validation = await validate2(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate2([
  PrimaryGeneratedColumn2("uuid"),
  _ts_metadata2("design:type", String)
], IdentityMetadataItemEntity.prototype, "id", void 0);
_ts_decorate2([
  Column2("varchar", {
    name: "label",
    length: 255,
    nullable: false
  }),
  IsNotEmpty2({
    message: "Blank metadata labels are not allowed"
  }),
  _ts_metadata2("design:type", String)
], IdentityMetadataItemEntity.prototype, "label", void 0);
_ts_decorate2([
  Column2("varchar", {
    name: "valueType",
    nullable: false
  }),
  IsNotEmpty2({
    message: "valueType must not be empty"
  }),
  _ts_metadata2("design:type", String)
], IdentityMetadataItemEntity.prototype, "valueType", void 0);
_ts_decorate2([
  Column2("varchar", {
    name: "stringValue",
    length: 255,
    nullable: true
  }),
  _ts_metadata2("design:type", String)
], IdentityMetadataItemEntity.prototype, "stringValue", void 0);
_ts_decorate2([
  Column2("numeric", {
    name: "numberValue",
    nullable: true
  }),
  _ts_metadata2("design:type", Number)
], IdentityMetadataItemEntity.prototype, "numberValue", void 0);
_ts_decorate2([
  Column2({
    name: "dateValue",
    nullable: true,
    type: typeOrmDateTime()
  }),
  _ts_metadata2("design:type", typeof Date === "undefined" ? Object : Date)
], IdentityMetadataItemEntity.prototype, "dateValue", void 0);
_ts_decorate2([
  Column2("boolean", {
    name: "boolValue",
    nullable: true
  }),
  _ts_metadata2("design:type", Boolean)
], IdentityMetadataItemEntity.prototype, "boolValue", void 0);
_ts_decorate2([
  ManyToOne(() => IdentityEntity, (identity) => identity.metadata, {
    cascade: [
      "insert",
      "update"
    ],
    onDelete: "CASCADE"
  }),
  _ts_metadata2("design:type", typeof IdentityEntity === "undefined" ? Object : IdentityEntity)
], IdentityMetadataItemEntity.prototype, "identity", void 0);
_ts_decorate2([
  BeforeInsert2(),
  BeforeUpdate2(),
  _ts_metadata2("design:type", Function),
  _ts_metadata2("design:paramtypes", []),
  _ts_metadata2("design:returntype", Promise)
], IdentityMetadataItemEntity.prototype, "validate", null);
IdentityMetadataItemEntity = _ts_decorate2([
  Entity2("IdentityMetadata")
], IdentityMetadataItemEntity);

// src/entities/contact/PartyEntity.ts
import { BaseEntity as BaseEntity7, BeforeInsert as BeforeInsert9, BeforeUpdate as BeforeUpdate9, Column as Column8, CreateDateColumn as CreateDateColumn6, Entity as Entity9, JoinColumn as JoinColumn4, ManyToOne as ManyToOne6, OneToMany as OneToMany3, OneToOne as OneToOne3, PrimaryGeneratedColumn as PrimaryGeneratedColumn9, UpdateDateColumn as UpdateDateColumn6 } from "typeorm";
import { typeOrmDateTime as typeOrmDateTime8 } from "@sphereon/ssi-sdk.agent-config";
import { validate as validate7 } from "class-validator";

// src/entities/contact/PartyTypeEntity.ts
import { BeforeInsert as BeforeInsert3, BeforeUpdate as BeforeUpdate3, Column as Column3, CreateDateColumn, Entity as Entity3, Index, OneToMany, PrimaryGeneratedColumn as PrimaryGeneratedColumn3, UpdateDateColumn } from "typeorm";
import { typeOrmDateTime as typeOrmDateTime2 } from "@sphereon/ssi-sdk.agent-config";
import { IsNotEmpty as IsNotEmpty3, Validate, validate as validate3 } from "class-validator";

// src/entities/validators/index.ts
import { ValidatorConstraint } from "class-validator";
function _ts_decorate3(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_decorate3, "_ts_decorate");
var IsNonEmptyStringConstraint = class {
  static {
    __name(this, "IsNonEmptyStringConstraint");
  }
  validate(value, args) {
    return !isEmptyString(value);
  }
  defaultMessage(args) {
    return `${args.property} must not be an empty string.`;
  }
};
IsNonEmptyStringConstraint = _ts_decorate3([
  ValidatorConstraint({
    name: "isNonEmptyString",
    async: false
  })
], IsNonEmptyStringConstraint);
var isEmptyString = /* @__PURE__ */ __name((value) => {
  return typeof value === "string" && value.trim().length === 0;
}, "isEmptyString");

// src/entities/contact/PartyTypeEntity.ts
function _ts_decorate4(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_decorate4, "_ts_decorate");
function _ts_metadata3(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata3, "_ts_metadata");
var PartyTypeEntity = class {
  static {
    __name(this, "PartyTypeEntity");
  }
  id;
  type;
  origin;
  name;
  description;
  tenantId;
  parties;
  createdAt;
  lastUpdatedAt;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
  async validate() {
    const validation = await validate3(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate4([
  PrimaryGeneratedColumn3("uuid"),
  _ts_metadata3("design:type", String)
], PartyTypeEntity.prototype, "id", void 0);
_ts_decorate4([
  Column3("simple-enum", {
    name: "type",
    enum: PartyTypeType,
    nullable: false
  }),
  _ts_metadata3("design:type", typeof PartyTypeType === "undefined" ? Object : PartyTypeType)
], PartyTypeEntity.prototype, "type", void 0);
_ts_decorate4([
  Column3("simple-enum", {
    name: "origin",
    enum: PartyOrigin,
    nullable: false,
    unique: false
  }),
  _ts_metadata3("design:type", typeof PartyOrigin === "undefined" ? Object : PartyOrigin)
], PartyTypeEntity.prototype, "origin", void 0);
_ts_decorate4([
  Column3("varchar", {
    name: "name",
    length: 255,
    nullable: false,
    unique: true
  }),
  IsNotEmpty3({
    message: "Blank names are not allowed"
  }),
  _ts_metadata3("design:type", String)
], PartyTypeEntity.prototype, "name", void 0);
_ts_decorate4([
  Column3("varchar", {
    name: "description",
    length: 255,
    nullable: true
  }),
  Validate(IsNonEmptyStringConstraint, {
    message: "Blank descriptions are not allowed"
  }),
  _ts_metadata3("design:type", String)
], PartyTypeEntity.prototype, "description", void 0);
_ts_decorate4([
  Column3({
    name: "tenant_id",
    type: "varchar",
    length: 255,
    nullable: true
  }),
  IsNotEmpty3({
    message: "Blank tenant id's are not allowed"
  }),
  _ts_metadata3("design:type", String)
], PartyTypeEntity.prototype, "tenantId", void 0);
_ts_decorate4([
  OneToMany(() => PartyEntity, (party) => party.partyType, {
    nullable: false
  }),
  _ts_metadata3("design:type", typeof Array === "undefined" ? Object : Array)
], PartyTypeEntity.prototype, "parties", void 0);
_ts_decorate4([
  CreateDateColumn({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime2()
  }),
  _ts_metadata3("design:type", typeof Date === "undefined" ? Object : Date)
], PartyTypeEntity.prototype, "createdAt", void 0);
_ts_decorate4([
  UpdateDateColumn({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime2()
  }),
  _ts_metadata3("design:type", typeof Date === "undefined" ? Object : Date)
], PartyTypeEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate4([
  BeforeInsert3(),
  BeforeUpdate3(),
  _ts_metadata3("design:type", Function),
  _ts_metadata3("design:paramtypes", []),
  _ts_metadata3("design:returntype", void 0)
], PartyTypeEntity.prototype, "updateUpdatedDate", null);
_ts_decorate4([
  BeforeInsert3(),
  BeforeUpdate3(),
  _ts_metadata3("design:type", Function),
  _ts_metadata3("design:paramtypes", []),
  _ts_metadata3("design:returntype", Promise)
], PartyTypeEntity.prototype, "validate", null);
PartyTypeEntity = _ts_decorate4([
  Entity3("PartyType"),
  Index("IDX_PartyType_type_tenant_id", [
    "type",
    "tenantId"
  ], {
    unique: true
  })
], PartyTypeEntity);

// src/entities/contact/BaseContactEntity.ts
import typeorm3 from "typeorm";
import { typeOrmDateTime as typeOrmDateTime4 } from "@sphereon/ssi-sdk.agent-config";

// src/entities/contact/ContactMetadataItemEntity.ts
import typeorm2 from "typeorm";
import { typeOrmDateTime as typeOrmDateTime3 } from "@sphereon/ssi-sdk.agent-config";
import { IsNotEmpty as IsNotEmpty4, validate as validate4 } from "class-validator";
function _ts_decorate5(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_decorate5, "_ts_decorate");
function _ts_metadata4(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata4, "_ts_metadata");
var { Entity: Entity4, Column: Column4, PrimaryGeneratedColumn: PrimaryGeneratedColumn4, BaseEntity: BaseEntity3, ManyToOne: ManyToOne2, BeforeInsert: BeforeInsert4, BeforeUpdate: BeforeUpdate4 } = typeorm2;
var ContactMetadataItemEntity = class extends BaseEntity3 {
  static {
    __name(this, "ContactMetadataItemEntity");
  }
  id;
  label;
  valueType;
  stringValue;
  numberValue;
  dateValue;
  boolValue;
  contact;
  async validate() {
    const validation = await validate4(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate5([
  PrimaryGeneratedColumn4("uuid"),
  _ts_metadata4("design:type", String)
], ContactMetadataItemEntity.prototype, "id", void 0);
_ts_decorate5([
  Column4("varchar", {
    name: "label",
    length: 255,
    nullable: false
  }),
  IsNotEmpty4({
    message: "Blank metadata labels are not allowed"
  }),
  _ts_metadata4("design:type", String)
], ContactMetadataItemEntity.prototype, "label", void 0);
_ts_decorate5([
  Column4("varchar", {
    name: "valueType",
    nullable: false
  }),
  IsNotEmpty4({
    message: "valueType must not be empty"
  }),
  _ts_metadata4("design:type", String)
], ContactMetadataItemEntity.prototype, "valueType", void 0);
_ts_decorate5([
  Column4("varchar", {
    name: "stringValue",
    length: 255,
    nullable: true
  }),
  _ts_metadata4("design:type", String)
], ContactMetadataItemEntity.prototype, "stringValue", void 0);
_ts_decorate5([
  Column4("numeric", {
    name: "numberValue",
    nullable: true
  }),
  _ts_metadata4("design:type", Number)
], ContactMetadataItemEntity.prototype, "numberValue", void 0);
_ts_decorate5([
  Column4({
    name: "dateValue",
    nullable: true,
    type: typeOrmDateTime3()
  }),
  _ts_metadata4("design:type", typeof Date === "undefined" ? Object : Date)
], ContactMetadataItemEntity.prototype, "dateValue", void 0);
_ts_decorate5([
  Column4("boolean", {
    name: "boolValue",
    nullable: true
  }),
  _ts_metadata4("design:type", Boolean)
], ContactMetadataItemEntity.prototype, "boolValue", void 0);
_ts_decorate5([
  ManyToOne2(() => BaseContactEntity, (contact) => contact.metadata, {
    cascade: [
      "insert",
      "update"
    ],
    onDelete: "CASCADE"
  }),
  _ts_metadata4("design:type", typeof BaseContactEntity === "undefined" ? Object : BaseContactEntity)
], ContactMetadataItemEntity.prototype, "contact", void 0);
_ts_decorate5([
  BeforeInsert4(),
  BeforeUpdate4(),
  _ts_metadata4("design:type", Function),
  _ts_metadata4("design:paramtypes", []),
  _ts_metadata4("design:returntype", Promise)
], ContactMetadataItemEntity.prototype, "validate", null);
ContactMetadataItemEntity = _ts_decorate5([
  Entity4("ContactMetadata")
], ContactMetadataItemEntity);

// src/entities/contact/BaseContactEntity.ts
function _ts_decorate6(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_decorate6, "_ts_decorate");
function _ts_metadata5(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata5, "_ts_metadata");
var { BaseEntity: BaseEntity4, BeforeInsert: BeforeInsert5, BeforeUpdate: BeforeUpdate5, CreateDateColumn: CreateDateColumn2, Entity: Entity5, JoinColumn: JoinColumn2, OneToMany: OneToMany2, OneToOne: OneToOne2, PrimaryGeneratedColumn: PrimaryGeneratedColumn5, TableInheritance, UpdateDateColumn: UpdateDateColumn2 } = typeorm3;
var BaseContactEntity = class extends BaseEntity4 {
  static {
    __name(this, "BaseContactEntity");
  }
  id;
  createdAt;
  lastUpdatedAt;
  party;
  metadata;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
};
_ts_decorate6([
  PrimaryGeneratedColumn5("uuid"),
  _ts_metadata5("design:type", String)
], BaseContactEntity.prototype, "id", void 0);
_ts_decorate6([
  CreateDateColumn2({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime4()
  }),
  _ts_metadata5("design:type", typeof Date === "undefined" ? Object : Date)
], BaseContactEntity.prototype, "createdAt", void 0);
_ts_decorate6([
  UpdateDateColumn2({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime4()
  }),
  _ts_metadata5("design:type", typeof Date === "undefined" ? Object : Date)
], BaseContactEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate6([
  OneToOne2(() => PartyEntity, (party) => party.contact, {
    onDelete: "CASCADE"
  }),
  JoinColumn2({
    name: "party_id"
  }),
  _ts_metadata5("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], BaseContactEntity.prototype, "party", void 0);
_ts_decorate6([
  OneToMany2(() => ContactMetadataItemEntity, (metadata) => metadata.contact, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn2({
    name: "metadata_id"
  }),
  _ts_metadata5("design:type", typeof Array === "undefined" ? Object : Array)
], BaseContactEntity.prototype, "metadata", void 0);
_ts_decorate6([
  BeforeInsert5(),
  BeforeUpdate5(),
  _ts_metadata5("design:type", Function),
  _ts_metadata5("design:paramtypes", []),
  _ts_metadata5("design:returntype", void 0)
], BaseContactEntity.prototype, "updateUpdatedDate", null);
BaseContactEntity = _ts_decorate6([
  Entity5("BaseContact"),
  TableInheritance({
    column: {
      type: "varchar",
      name: "type"
    }
  })
], BaseContactEntity);

// src/entities/contact/PartyRelationshipEntity.ts
import { Entity as Entity6, PrimaryGeneratedColumn as PrimaryGeneratedColumn6, CreateDateColumn as CreateDateColumn3, UpdateDateColumn as UpdateDateColumn3, ManyToOne as ManyToOne3, Column as Column5, Index as Index2, BeforeInsert as BeforeInsert6, BeforeUpdate as BeforeUpdate6, JoinColumn as JoinColumn3 } from "typeorm";
import { typeOrmDateTime as typeOrmDateTime5 } from "@sphereon/ssi-sdk.agent-config";
function _ts_decorate7(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_decorate7, "_ts_decorate");
function _ts_metadata6(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata6, "_ts_metadata");
var PartyRelationshipEntity = class {
  static {
    __name(this, "PartyRelationshipEntity");
  }
  id;
  left;
  leftId;
  right;
  rightId;
  ownerId;
  tenantId;
  createdAt;
  lastUpdatedAt;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
  async checkRelationshipSides() {
    if ((this.left?.id ?? this.leftId) === (this.right?.id ?? this.rightId)) {
      return Promise.reject(Error("Cannot use the same id for both sides of the relationship"));
    }
  }
};
_ts_decorate7([
  PrimaryGeneratedColumn6("uuid"),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "id", void 0);
_ts_decorate7([
  ManyToOne3(() => PartyEntity, {
    nullable: false,
    onDelete: "CASCADE"
  }),
  JoinColumn3({
    name: "left_id"
  }),
  _ts_metadata6("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], PartyRelationshipEntity.prototype, "left", void 0);
_ts_decorate7([
  Column5("text", {
    name: "left_id",
    nullable: false
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "leftId", void 0);
_ts_decorate7([
  ManyToOne3(() => PartyEntity, {
    nullable: false,
    onDelete: "CASCADE"
  }),
  JoinColumn3({
    name: "right_id"
  }),
  _ts_metadata6("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], PartyRelationshipEntity.prototype, "right", void 0);
_ts_decorate7([
  Column5("text", {
    name: "right_id",
    nullable: false
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "rightId", void 0);
_ts_decorate7([
  Column5("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "ownerId", void 0);
_ts_decorate7([
  Column5("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "tenantId", void 0);
_ts_decorate7([
  CreateDateColumn3({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime5()
  }),
  _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
], PartyRelationshipEntity.prototype, "createdAt", void 0);
_ts_decorate7([
  UpdateDateColumn3({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime5()
  }),
  _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
], PartyRelationshipEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate7([
  BeforeInsert6(),
  BeforeUpdate6(),
  _ts_metadata6("design:type", Function),
  _ts_metadata6("design:paramtypes", []),
  _ts_metadata6("design:returntype", void 0)
], PartyRelationshipEntity.prototype, "updateUpdatedDate", null);
_ts_decorate7([
  BeforeInsert6(),
  BeforeUpdate6(),
  _ts_metadata6("design:type", Function),
  _ts_metadata6("design:paramtypes", []),
  _ts_metadata6("design:returntype", Promise)
], PartyRelationshipEntity.prototype, "checkRelationshipSides", null);
PartyRelationshipEntity = _ts_decorate7([
  Entity6("PartyRelationship"),
  Index2("IDX_PartyRelationship_left_right", [
    "left",
    "right"
  ], {
    unique: true
  })
], PartyRelationshipEntity);

// src/entities/contact/ElectronicAddressEntity.ts
import { IsNotEmpty as IsNotEmpty5, validate as validate5 } from "class-validator";
import typeorm4 from "typeorm";
import { typeOrmDateTime as typeOrmDateTime6 } from "@sphereon/ssi-sdk.agent-config";
function _ts_decorate8(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_decorate8, "_ts_decorate");
function _ts_metadata7(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata7, "_ts_metadata");
var { Entity: Entity7, Column: Column6, PrimaryGeneratedColumn: PrimaryGeneratedColumn7, BaseEntity: BaseEntity5, ManyToOne: ManyToOne4, BeforeInsert: BeforeInsert7, BeforeUpdate: BeforeUpdate7, CreateDateColumn: CreateDateColumn4, UpdateDateColumn: UpdateDateColumn4 } = typeorm4;
var ElectronicAddressEntity = class extends BaseEntity5 {
  static {
    __name(this, "ElectronicAddressEntity");
  }
  id;
  type;
  electronicAddress;
  party;
  partyId;
  ownerId;
  tenantId;
  createdAt;
  lastUpdatedAt;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
  async validate() {
    const validation = await validate5(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate8([
  PrimaryGeneratedColumn7("uuid"),
  _ts_metadata7("design:type", String)
], ElectronicAddressEntity.prototype, "id", void 0);
_ts_decorate8([
  Column6("varchar", {
    name: "type",
    length: 255,
    nullable: false
  }),
  IsNotEmpty5({
    message: "Blank electronic address types are not allowed"
  }),
  _ts_metadata7("design:type", typeof ElectronicAddressType === "undefined" ? Object : ElectronicAddressType)
], ElectronicAddressEntity.prototype, "type", void 0);
_ts_decorate8([
  Column6("varchar", {
    name: "electronic_address",
    length: 255,
    nullable: false
  }),
  IsNotEmpty5({
    message: "Blank electronic addresses are not allowed"
  }),
  _ts_metadata7("design:type", String)
], ElectronicAddressEntity.prototype, "electronicAddress", void 0);
_ts_decorate8([
  ManyToOne4(() => PartyEntity, (party) => party.electronicAddresses, {
    onDelete: "CASCADE"
  }),
  _ts_metadata7("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], ElectronicAddressEntity.prototype, "party", void 0);
_ts_decorate8([
  Column6("text", {
    name: "partyId",
    nullable: true
  }),
  _ts_metadata7("design:type", String)
], ElectronicAddressEntity.prototype, "partyId", void 0);
_ts_decorate8([
  Column6("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata7("design:type", String)
], ElectronicAddressEntity.prototype, "ownerId", void 0);
_ts_decorate8([
  Column6("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata7("design:type", String)
], ElectronicAddressEntity.prototype, "tenantId", void 0);
_ts_decorate8([
  CreateDateColumn4({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime6()
  }),
  _ts_metadata7("design:type", typeof Date === "undefined" ? Object : Date)
], ElectronicAddressEntity.prototype, "createdAt", void 0);
_ts_decorate8([
  UpdateDateColumn4({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime6()
  }),
  _ts_metadata7("design:type", typeof Date === "undefined" ? Object : Date)
], ElectronicAddressEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate8([
  BeforeInsert7(),
  BeforeUpdate7(),
  _ts_metadata7("design:type", Function),
  _ts_metadata7("design:paramtypes", []),
  _ts_metadata7("design:returntype", void 0)
], ElectronicAddressEntity.prototype, "updateUpdatedDate", null);
_ts_decorate8([
  BeforeInsert7(),
  BeforeUpdate7(),
  _ts_metadata7("design:type", Function),
  _ts_metadata7("design:paramtypes", []),
  _ts_metadata7("design:returntype", Promise)
], ElectronicAddressEntity.prototype, "validate", null);
ElectronicAddressEntity = _ts_decorate8([
  Entity7("ElectronicAddress")
], ElectronicAddressEntity);

// src/entities/contact/PhysicalAddressEntity.ts
import { IsNotEmpty as IsNotEmpty6, Validate as Validate2, validate as validate6 } from "class-validator";
import { BaseEntity as BaseEntity6, BeforeInsert as BeforeInsert8, BeforeUpdate as BeforeUpdate8, Column as Column7, CreateDateColumn as CreateDateColumn5, Entity as Entity8, ManyToOne as ManyToOne5, PrimaryGeneratedColumn as PrimaryGeneratedColumn8, UpdateDateColumn as UpdateDateColumn5 } from "typeorm";
import { typeOrmDateTime as typeOrmDateTime7 } from "@sphereon/ssi-sdk.agent-config";
function _ts_decorate9(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_decorate9, "_ts_decorate");
function _ts_metadata8(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata8, "_ts_metadata");
var PhysicalAddressEntity = class extends BaseEntity6 {
  static {
    __name(this, "PhysicalAddressEntity");
  }
  id;
  type;
  streetName;
  streetNumber;
  postalCode;
  cityName;
  provinceName;
  countryCode;
  buildingName;
  ownerId;
  tenantId;
  party;
  partyId;
  createdAt;
  lastUpdatedAt;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
  async validate() {
    const validation = await validate6(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate9([
  PrimaryGeneratedColumn8("uuid"),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "id", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "type",
    length: 255,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank physical address types are not allowed"
  }),
  _ts_metadata8("design:type", typeof PhysicalAddressType === "undefined" ? Object : PhysicalAddressType)
], PhysicalAddressEntity.prototype, "type", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "street_name",
    length: 255,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank street names are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "streetName", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "street_number",
    length: 255,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank street numbers are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "streetNumber", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "postal_code",
    length: 255,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank postal codes are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "postalCode", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "city_name",
    length: 255,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank city names are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "cityName", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "province_name",
    length: 255,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank province names are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "provinceName", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "country_code",
    length: 2,
    nullable: false
  }),
  IsNotEmpty6({
    message: "Blank country codes are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "countryCode", void 0);
_ts_decorate9([
  Column7("varchar", {
    name: "building_name",
    length: 255,
    nullable: true
  }),
  Validate2(IsNonEmptyStringConstraint, {
    message: "Blank building names are not allowed"
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "buildingName", void 0);
_ts_decorate9([
  Column7("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "ownerId", void 0);
_ts_decorate9([
  Column7("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "tenantId", void 0);
_ts_decorate9([
  ManyToOne5(() => PartyEntity, (party) => party.physicalAddresses, {
    onDelete: "CASCADE"
  }),
  _ts_metadata8("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], PhysicalAddressEntity.prototype, "party", void 0);
_ts_decorate9([
  Column7("text", {
    name: "partyId",
    nullable: true
  }),
  _ts_metadata8("design:type", String)
], PhysicalAddressEntity.prototype, "partyId", void 0);
_ts_decorate9([
  CreateDateColumn5({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime7()
  }),
  _ts_metadata8("design:type", typeof Date === "undefined" ? Object : Date)
], PhysicalAddressEntity.prototype, "createdAt", void 0);
_ts_decorate9([
  UpdateDateColumn5({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime7()
  }),
  _ts_metadata8("design:type", typeof Date === "undefined" ? Object : Date)
], PhysicalAddressEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate9([
  BeforeInsert8(),
  BeforeUpdate8(),
  _ts_metadata8("design:type", Function),
  _ts_metadata8("design:paramtypes", []),
  _ts_metadata8("design:returntype", void 0)
], PhysicalAddressEntity.prototype, "updateUpdatedDate", null);
_ts_decorate9([
  BeforeInsert8(),
  BeforeUpdate8(),
  _ts_metadata8("design:type", Function),
  _ts_metadata8("design:paramtypes", []),
  _ts_metadata8("design:returntype", Promise)
], PhysicalAddressEntity.prototype, "validate", null);
PhysicalAddressEntity = _ts_decorate9([
  Entity8("PhysicalAddress")
], PhysicalAddressEntity);

// src/entities/contact/PartyEntity.ts
function _ts_decorate10(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_decorate10, "_ts_decorate");
function _ts_metadata9(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata9, "_ts_metadata");
var PartyEntity = class extends BaseEntity7 {
  static {
    __name(this, "PartyEntity");
  }
  id;
  uri;
  ownerId;
  tenantId;
  identities;
  electronicAddresses;
  physicalAddresses;
  partyType;
  contact;
  relationships;
  createdAt;
  lastUpdatedAt;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
  async validate() {
    const validation = await validate7(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate10([
  PrimaryGeneratedColumn9("uuid"),
  _ts_metadata9("design:type", String)
], PartyEntity.prototype, "id", void 0);
_ts_decorate10([
  Column8("varchar", {
    name: "uri",
    length: 255,
    nullable: true
  }),
  _ts_metadata9("design:type", String)
], PartyEntity.prototype, "uri", void 0);
_ts_decorate10([
  Column8("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata9("design:type", String)
], PartyEntity.prototype, "ownerId", void 0);
_ts_decorate10([
  Column8("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata9("design:type", String)
], PartyEntity.prototype, "tenantId", void 0);
_ts_decorate10([
  OneToMany3(() => IdentityEntity, (identity) => identity.party, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn4({
    name: "identity_id"
  }),
  _ts_metadata9("design:type", typeof Array === "undefined" ? Object : Array)
], PartyEntity.prototype, "identities", void 0);
_ts_decorate10([
  OneToMany3(() => ElectronicAddressEntity, (electronicAddress) => electronicAddress.party, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn4({
    name: "electronic_address_id"
  }),
  _ts_metadata9("design:type", typeof Array === "undefined" ? Object : Array)
], PartyEntity.prototype, "electronicAddresses", void 0);
_ts_decorate10([
  OneToMany3(() => PhysicalAddressEntity, (physicalAddress) => physicalAddress.party, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn4({
    name: "physical_address_id"
  }),
  _ts_metadata9("design:type", typeof Array === "undefined" ? Object : Array)
], PartyEntity.prototype, "physicalAddresses", void 0);
_ts_decorate10([
  ManyToOne6(() => PartyTypeEntity, (contactType) => contactType.parties, {
    cascade: true,
    nullable: false,
    eager: true
  }),
  JoinColumn4({
    name: "party_type_id"
  }),
  _ts_metadata9("design:type", typeof PartyTypeEntity === "undefined" ? Object : PartyTypeEntity)
], PartyEntity.prototype, "partyType", void 0);
_ts_decorate10([
  OneToOne3(() => BaseContactEntity, (contact) => contact.party, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  _ts_metadata9("design:type", typeof BaseContactEntity === "undefined" ? Object : BaseContactEntity)
], PartyEntity.prototype, "contact", void 0);
_ts_decorate10([
  OneToMany3(() => PartyRelationshipEntity, (relationship) => relationship.left, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn4({
    name: "relationship_id"
  }),
  _ts_metadata9("design:type", typeof Array === "undefined" ? Object : Array)
], PartyEntity.prototype, "relationships", void 0);
_ts_decorate10([
  CreateDateColumn6({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime8()
  }),
  _ts_metadata9("design:type", typeof Date === "undefined" ? Object : Date)
], PartyEntity.prototype, "createdAt", void 0);
_ts_decorate10([
  UpdateDateColumn6({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime8()
  }),
  _ts_metadata9("design:type", typeof Date === "undefined" ? Object : Date)
], PartyEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate10([
  BeforeInsert9(),
  BeforeUpdate9(),
  _ts_metadata9("design:type", Function),
  _ts_metadata9("design:paramtypes", []),
  _ts_metadata9("design:returntype", void 0)
], PartyEntity.prototype, "updateUpdatedDate", null);
_ts_decorate10([
  BeforeInsert9(),
  BeforeUpdate9(),
  _ts_metadata9("design:type", Function),
  _ts_metadata9("design:paramtypes", []),
  _ts_metadata9("design:returntype", Promise)
], PartyEntity.prototype, "validate", null);
PartyEntity = _ts_decorate10([
  Entity9("Party")
], PartyEntity);

// src/entities/contact/IdentityEntity.ts
function _ts_decorate11(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_decorate11, "_ts_decorate");
function _ts_metadata10(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata10, "_ts_metadata");
var IdentityEntity = class extends BaseEntity8 {
  static {
    __name(this, "IdentityEntity");
  }
  id;
  alias;
  origin;
  ownerId;
  tenantId;
  roles;
  identifier;
  connection;
  metadata;
  createdAt;
  lastUpdatedAt;
  party;
  partyId;
  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
  updateUpdatedDate() {
    this.lastUpdatedAt = /* @__PURE__ */ new Date();
  }
  async validate() {
    const validation = await validate8(this);
    if (validation.length > 0) {
      const constraint = getConstraint(validation[0]);
      if (constraint) {
        const message = Object.values(constraint)[0];
        return Promise.reject(Error(message));
      }
    }
  }
};
_ts_decorate11([
  PrimaryGeneratedColumn10("uuid"),
  _ts_metadata10("design:type", String)
], IdentityEntity.prototype, "id", void 0);
_ts_decorate11([
  Column9("varchar", {
    name: "alias",
    length: 255,
    nullable: false,
    unique: true
  }),
  IsNotEmpty7({
    message: "Blank aliases are not allowed"
  }),
  _ts_metadata10("design:type", String)
], IdentityEntity.prototype, "alias", void 0);
_ts_decorate11([
  Column9("simple-enum", {
    name: "origin",
    enum: IdentityOrigin,
    nullable: false
  }),
  _ts_metadata10("design:type", typeof IdentityOrigin === "undefined" ? Object : IdentityOrigin)
], IdentityEntity.prototype, "origin", void 0);
_ts_decorate11([
  Column9("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata10("design:type", String)
], IdentityEntity.prototype, "ownerId", void 0);
_ts_decorate11([
  Column9("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata10("design:type", String)
], IdentityEntity.prototype, "tenantId", void 0);
_ts_decorate11([
  Column9("simple-array", {
    name: "roles",
    nullable: false
  }),
  _ts_metadata10("design:type", typeof Array === "undefined" ? Object : Array)
], IdentityEntity.prototype, "roles", void