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

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

// src/index.ts
import { Entities as VeramoDataStoreEntities2 } from "@veramo/data-store";

// src/entities/contact/BaseConfigEntity.ts
import { BaseEntity as BaseEntity10, Entity as Entity12, JoinColumn as JoinColumn7, OneToOne as OneToOne6, PrimaryGeneratedColumn as PrimaryGeneratedColumn12, TableInheritance as TableInheritance2 } from "typeorm";

// src/entities/contact/ConnectionEntity.ts
import { ConnectionType } from "@sphereon/ssi-sdk.data-store-types";
import { BaseEntity as BaseEntity9, Column as Column10, Entity as Entity11, JoinColumn as JoinColumn6, OneToOne as OneToOne5, PrimaryGeneratedColumn as PrimaryGeneratedColumn11 } from "typeorm";

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

// 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
import { CorrelationIdentifierType } from "@sphereon/ssi-sdk.data-store-types";
import { IsNotEmpty, validate } from "class-validator";
import { BaseEntity, BeforeInsert, BeforeUpdate, Column, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } 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 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 { IsNotEmpty as IsNotEmpty2, validate as validate2 } from "class-validator";
import { BaseEntity as BaseEntity2, BeforeInsert as BeforeInsert2, BeforeUpdate as BeforeUpdate2, Column as Column2, Entity as Entity2, ManyToOne, PrimaryGeneratedColumn as PrimaryGeneratedColumn2 } from "typeorm";
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 { typeOrmDateTime as typeOrmDateTime8 } from "@sphereon/ssi-sdk.agent-config";
import { validate as validate7 } from "class-validator";
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";

// src/entities/contact/BaseContactEntity.ts
import { typeOrmDateTime as typeOrmDateTime3 } from "@sphereon/ssi-sdk.agent-config";
import { BaseEntity as BaseEntity4, BeforeInsert as BeforeInsert4, BeforeUpdate as BeforeUpdate4, CreateDateColumn, Entity as Entity4, JoinColumn as JoinColumn2, OneToMany, OneToOne as OneToOne2, PrimaryGeneratedColumn as PrimaryGeneratedColumn4, TableInheritance, UpdateDateColumn } from "typeorm";

// src/entities/contact/ContactMetadataItemEntity.ts
import { typeOrmDateTime as typeOrmDateTime2 } from "@sphereon/ssi-sdk.agent-config";
import { IsNotEmpty as IsNotEmpty3, validate as validate3 } from "class-validator";
import { BaseEntity as BaseEntity3, BeforeInsert as BeforeInsert3, BeforeUpdate as BeforeUpdate3, Column as Column3, Entity as Entity3, ManyToOne as ManyToOne2, PrimaryGeneratedColumn as PrimaryGeneratedColumn3 } from "typeorm";
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");
function _ts_metadata3(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata3, "_ts_metadata");
var ContactMetadataItemEntity = class extends BaseEntity3 {
  static {
    __name(this, "ContactMetadataItemEntity");
  }
  id;
  label;
  valueType;
  stringValue;
  numberValue;
  dateValue;
  boolValue;
  contact;
  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_decorate3([
  PrimaryGeneratedColumn3("uuid"),
  _ts_metadata3("design:type", String)
], ContactMetadataItemEntity.prototype, "id", void 0);
_ts_decorate3([
  Column3("varchar", {
    name: "label",
    length: 255,
    nullable: false
  }),
  IsNotEmpty3({
    message: "Blank metadata labels are not allowed"
  }),
  _ts_metadata3("design:type", String)
], ContactMetadataItemEntity.prototype, "label", void 0);
_ts_decorate3([
  Column3("varchar", {
    name: "valueType",
    nullable: false
  }),
  IsNotEmpty3({
    message: "valueType must not be empty"
  }),
  _ts_metadata3("design:type", String)
], ContactMetadataItemEntity.prototype, "valueType", void 0);
_ts_decorate3([
  Column3("varchar", {
    name: "stringValue",
    length: 255,
    nullable: true
  }),
  _ts_metadata3("design:type", String)
], ContactMetadataItemEntity.prototype, "stringValue", void 0);
_ts_decorate3([
  Column3("numeric", {
    name: "numberValue",
    nullable: true
  }),
  _ts_metadata3("design:type", Number)
], ContactMetadataItemEntity.prototype, "numberValue", void 0);
_ts_decorate3([
  Column3({
    name: "dateValue",
    nullable: true,
    type: typeOrmDateTime2()
  }),
  _ts_metadata3("design:type", typeof Date === "undefined" ? Object : Date)
], ContactMetadataItemEntity.prototype, "dateValue", void 0);
_ts_decorate3([
  Column3("boolean", {
    name: "boolValue",
    nullable: true
  }),
  _ts_metadata3("design:type", Boolean)
], ContactMetadataItemEntity.prototype, "boolValue", void 0);
_ts_decorate3([
  ManyToOne2(() => BaseContactEntity, (contact) => contact.metadata, {
    cascade: [
      "insert",
      "update"
    ],
    onDelete: "CASCADE"
  }),
  _ts_metadata3("design:type", typeof BaseContactEntity === "undefined" ? Object : BaseContactEntity)
], ContactMetadataItemEntity.prototype, "contact", void 0);
_ts_decorate3([
  BeforeInsert3(),
  BeforeUpdate3(),
  _ts_metadata3("design:type", Function),
  _ts_metadata3("design:paramtypes", []),
  _ts_metadata3("design:returntype", Promise)
], ContactMetadataItemEntity.prototype, "validate", null);
ContactMetadataItemEntity = _ts_decorate3([
  Entity3("ContactMetadata")
], ContactMetadataItemEntity);

// src/entities/contact/BaseContactEntity.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_metadata4(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata4, "_ts_metadata");
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_decorate4([
  PrimaryGeneratedColumn4("uuid"),
  _ts_metadata4("design:type", String)
], BaseContactEntity.prototype, "id", void 0);
_ts_decorate4([
  CreateDateColumn({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime3()
  }),
  _ts_metadata4("design:type", typeof Date === "undefined" ? Object : Date)
], BaseContactEntity.prototype, "createdAt", void 0);
_ts_decorate4([
  UpdateDateColumn({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime3()
  }),
  _ts_metadata4("design:type", typeof Date === "undefined" ? Object : Date)
], BaseContactEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate4([
  OneToOne2(() => PartyEntity, (party) => party.contact, {
    onDelete: "CASCADE"
  }),
  JoinColumn2({
    name: "party_id"
  }),
  _ts_metadata4("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], BaseContactEntity.prototype, "party", void 0);
_ts_decorate4([
  OneToMany(() => ContactMetadataItemEntity, (metadata) => metadata.contact, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn2({
    name: "metadata_id"
  }),
  _ts_metadata4("design:type", typeof Array === "undefined" ? Object : Array)
], BaseContactEntity.prototype, "metadata", void 0);
_ts_decorate4([
  BeforeInsert4(),
  BeforeUpdate4(),
  _ts_metadata4("design:type", Function),
  _ts_metadata4("design:paramtypes", []),
  _ts_metadata4("design:returntype", void 0)
], BaseContactEntity.prototype, "updateUpdatedDate", null);
BaseContactEntity = _ts_decorate4([
  Entity4("BaseContact"),
  TableInheritance({
    column: {
      type: "varchar",
      name: "type"
    }
  })
], BaseContactEntity);

// src/entities/contact/ElectronicAddressEntity.ts
import { typeOrmDateTime as typeOrmDateTime4 } from "@sphereon/ssi-sdk.agent-config";
import { IsNotEmpty as IsNotEmpty4, validate as validate4 } from "class-validator";
import { BaseEntity as BaseEntity5, BeforeInsert as BeforeInsert5, BeforeUpdate as BeforeUpdate5, Column as Column4, CreateDateColumn as CreateDateColumn2, Entity as Entity5, ManyToOne as ManyToOne3, PrimaryGeneratedColumn as PrimaryGeneratedColumn5, UpdateDateColumn as UpdateDateColumn2 } from "typeorm";
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_metadata5(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata5, "_ts_metadata");
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 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([
  PrimaryGeneratedColumn5("uuid"),
  _ts_metadata5("design:type", String)
], ElectronicAddressEntity.prototype, "id", void 0);
_ts_decorate5([
  Column4("varchar", {
    name: "type",
    length: 255,
    nullable: false
  }),
  IsNotEmpty4({
    message: "Blank electronic address types are not allowed"
  }),
  _ts_metadata5("design:type", typeof ElectronicAddressType === "undefined" ? Object : ElectronicAddressType)
], ElectronicAddressEntity.prototype, "type", void 0);
_ts_decorate5([
  Column4("varchar", {
    name: "electronic_address",
    length: 255,
    nullable: false
  }),
  IsNotEmpty4({
    message: "Blank electronic addresses are not allowed"
  }),
  _ts_metadata5("design:type", String)
], ElectronicAddressEntity.prototype, "electronicAddress", void 0);
_ts_decorate5([
  ManyToOne3(() => PartyEntity, (party) => party.electronicAddresses, {
    onDelete: "CASCADE"
  }),
  _ts_metadata5("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], ElectronicAddressEntity.prototype, "party", void 0);
_ts_decorate5([
  Column4("text", {
    name: "partyId",
    nullable: true
  }),
  _ts_metadata5("design:type", String)
], ElectronicAddressEntity.prototype, "partyId", void 0);
_ts_decorate5([
  Column4("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata5("design:type", String)
], ElectronicAddressEntity.prototype, "ownerId", void 0);
_ts_decorate5([
  Column4("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata5("design:type", String)
], ElectronicAddressEntity.prototype, "tenantId", void 0);
_ts_decorate5([
  CreateDateColumn2({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime4()
  }),
  _ts_metadata5("design:type", typeof Date === "undefined" ? Object : Date)
], ElectronicAddressEntity.prototype, "createdAt", void 0);
_ts_decorate5([
  UpdateDateColumn2({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime4()
  }),
  _ts_metadata5("design:type", typeof Date === "undefined" ? Object : Date)
], ElectronicAddressEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate5([
  BeforeInsert5(),
  BeforeUpdate5(),
  _ts_metadata5("design:type", Function),
  _ts_metadata5("design:paramtypes", []),
  _ts_metadata5("design:returntype", void 0)
], ElectronicAddressEntity.prototype, "updateUpdatedDate", null);
_ts_decorate5([
  BeforeInsert5(),
  BeforeUpdate5(),
  _ts_metadata5("design:type", Function),
  _ts_metadata5("design:paramtypes", []),
  _ts_metadata5("design:returntype", Promise)
], ElectronicAddressEntity.prototype, "validate", null);
ElectronicAddressEntity = _ts_decorate5([
  Entity5("ElectronicAddress")
], ElectronicAddressEntity);

// src/entities/contact/PartyRelationshipEntity.ts
import { typeOrmDateTime as typeOrmDateTime5 } from "@sphereon/ssi-sdk.agent-config";
import { BeforeInsert as BeforeInsert6, BeforeUpdate as BeforeUpdate6, Column as Column5, CreateDateColumn as CreateDateColumn3, Entity as Entity6, Index, JoinColumn as JoinColumn3, ManyToOne as ManyToOne4, PrimaryGeneratedColumn as PrimaryGeneratedColumn6, UpdateDateColumn as UpdateDateColumn3 } from "typeorm";
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_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_decorate6([
  PrimaryGeneratedColumn6("uuid"),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "id", void 0);
_ts_decorate6([
  ManyToOne4(() => PartyEntity, {
    nullable: false,
    onDelete: "CASCADE"
  }),
  JoinColumn3({
    name: "left_id"
  }),
  _ts_metadata6("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], PartyRelationshipEntity.prototype, "left", void 0);
_ts_decorate6([
  Column5("text", {
    name: "left_id",
    nullable: false
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "leftId", void 0);
_ts_decorate6([
  ManyToOne4(() => PartyEntity, {
    nullable: false,
    onDelete: "CASCADE"
  }),
  JoinColumn3({
    name: "right_id"
  }),
  _ts_metadata6("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], PartyRelationshipEntity.prototype, "right", void 0);
_ts_decorate6([
  Column5("text", {
    name: "right_id",
    nullable: false
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "rightId", void 0);
_ts_decorate6([
  Column5("text", {
    name: "owner_id",
    nullable: true
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "ownerId", void 0);
_ts_decorate6([
  Column5("text", {
    name: "tenant_id",
    nullable: true
  }),
  _ts_metadata6("design:type", String)
], PartyRelationshipEntity.prototype, "tenantId", void 0);
_ts_decorate6([
  CreateDateColumn3({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime5()
  }),
  _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
], PartyRelationshipEntity.prototype, "createdAt", void 0);
_ts_decorate6([
  UpdateDateColumn3({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime5()
  }),
  _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
], PartyRelationshipEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate6([
  BeforeInsert6(),
  BeforeUpdate6(),
  _ts_metadata6("design:type", Function),
  _ts_metadata6("design:paramtypes", []),
  _ts_metadata6("design:returntype", void 0)
], PartyRelationshipEntity.prototype, "updateUpdatedDate", null);
_ts_decorate6([
  BeforeInsert6(),
  BeforeUpdate6(),
  _ts_metadata6("design:type", Function),
  _ts_metadata6("design:paramtypes", []),
  _ts_metadata6("design:returntype", Promise)
], PartyRelationshipEntity.prototype, "checkRelationshipSides", null);
PartyRelationshipEntity = _ts_decorate6([
  Entity6("PartyRelationship"),
  Index("IDX_PartyRelationship_left_right", [
    "left",
    "right"
  ], {
    unique: true
  })
], PartyRelationshipEntity);

// src/entities/contact/PartyTypeEntity.ts
import { typeOrmDateTime as typeOrmDateTime6 } from "@sphereon/ssi-sdk.agent-config";
import { PartyOrigin, PartyTypeType } from "@sphereon/ssi-sdk.data-store-types";
import { IsNotEmpty as IsNotEmpty5, Validate, validate as validate5 } from "class-validator";
import { BeforeInsert as BeforeInsert7, BeforeUpdate as BeforeUpdate7, Column as Column6, CreateDateColumn as CreateDateColumn4, Entity as Entity7, Index as Index2, OneToMany as OneToMany2, PrimaryGeneratedColumn as PrimaryGeneratedColumn7, UpdateDateColumn as UpdateDateColumn4 } from "typeorm";

// src/entities/validators/index.ts
import { ValidatorConstraint } from "class-validator";
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");
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_decorate7([
  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_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 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 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)
], PartyTypeEntity.prototype, "id", void 0);
_ts_decorate8([
  Column6("simple-enum", {
    name: "type",
    enum: PartyTypeType,
    nullable: false
  }),
  _ts_metadata7("design:type", typeof PartyTypeType === "undefined" ? Object : PartyTypeType)
], PartyTypeEntity.prototype, "type", void 0);
_ts_decorate8([
  Column6("simple-enum", {
    name: "origin",
    enum: PartyOrigin,
    nullable: false,
    unique: false
  }),
  _ts_metadata7("design:type", typeof PartyOrigin === "undefined" ? Object : PartyOrigin)
], PartyTypeEntity.prototype, "origin", void 0);
_ts_decorate8([
  Column6("varchar", {
    name: "name",
    length: 255,
    nullable: false,
    unique: true
  }),
  IsNotEmpty5({
    message: "Blank names are not allowed"
  }),
  _ts_metadata7("design:type", String)
], PartyTypeEntity.prototype, "name", void 0);
_ts_decorate8([
  Column6("varchar", {
    name: "description",
    length: 255,
    nullable: true
  }),
  Validate(IsNonEmptyStringConstraint, {
    message: "Blank descriptions are not allowed"
  }),
  _ts_metadata7("design:type", String)
], PartyTypeEntity.prototype, "description", void 0);
_ts_decorate8([
  Column6({
    name: "tenant_id",
    type: "varchar",
    length: 255,
    nullable: true
  }),
  IsNotEmpty5({
    message: "Blank tenant id's are not allowed"
  }),
  _ts_metadata7("design:type", String)
], PartyTypeEntity.prototype, "tenantId", void 0);
_ts_decorate8([
  OneToMany2(() => PartyEntity, (party) => party.partyType, {
    nullable: false
  }),
  _ts_metadata7("design:type", typeof Array === "undefined" ? Object : Array)
], PartyTypeEntity.prototype, "parties", void 0);
_ts_decorate8([
  CreateDateColumn4({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime6()
  }),
  _ts_metadata7("design:type", typeof Date === "undefined" ? Object : Date)
], PartyTypeEntity.prototype, "createdAt", void 0);
_ts_decorate8([
  UpdateDateColumn4({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime6()
  }),
  _ts_metadata7("design:type", typeof Date === "undefined" ? Object : Date)
], PartyTypeEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate8([
  BeforeInsert7(),
  BeforeUpdate7(),
  _ts_metadata7("design:type", Function),
  _ts_metadata7("design:paramtypes", []),
  _ts_metadata7("design:returntype", void 0)
], PartyTypeEntity.prototype, "updateUpdatedDate", null);
_ts_decorate8([
  BeforeInsert7(),
  BeforeUpdate7(),
  _ts_metadata7("design:type", Function),
  _ts_metadata7("design:paramtypes", []),
  _ts_metadata7("design:returntype", Promise)
], PartyTypeEntity.prototype, "validate", null);
PartyTypeEntity = _ts_decorate8([
  Entity7("PartyType"),
  Index2("IDX_PartyType_type_tenant_id", [
    "type",
    "tenantId"
  ], {
    unique: true
  })
], PartyTypeEntity);

// src/entities/contact/PhysicalAddressEntity.ts
import { typeOrmDateTime as typeOrmDateTime7 } from "@sphereon/ssi-sdk.agent-config";
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";
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 0);
_ts_decorate11([
  OneToOne4(() => CorrelationIdentifierEntity, (identifier) => identifier.identity, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  _ts_metadata10("design:type", typeof CorrelationIdentifierEntity === "undefined" ? Object : CorrelationIdentifierEntity)
], IdentityEntity.prototype, "identifier", void 0);
_ts_decorate11([
  OneToOne4(() => ConnectionEntity, (connection) => connection.identity, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true
  }),
  _ts_metadata10("design:type", typeof ConnectionEntity === "undefined" ? Object : ConnectionEntity)
], IdentityEntity.prototype, "connection", void 0);
_ts_decorate11([
  OneToMany4(() => IdentityMetadataItemEntity, (metadata) => metadata.identity, {
    cascade: true,
    onDelete: "CASCADE",
    eager: true,
    nullable: false
  }),
  JoinColumn5({
    name: "metadata_id"
  }),
  _ts_metadata10("design:type", typeof Array === "undefined" ? Object : Array)
], IdentityEntity.prototype, "metadata", void 0);
_ts_decorate11([
  CreateDateColumn7({
    name: "created_at",
    nullable: false,
    type: typeOrmDateTime9()
  }),
  _ts_metadata10("design:type", typeof Date === "undefined" ? Object : Date)
], IdentityEntity.prototype, "createdAt", void 0);
_ts_decorate11([
  UpdateDateColumn7({
    name: "last_updated_at",
    nullable: false,
    type: typeOrmDateTime9()
  }),
  _ts_metadata10("design:type", typeof Date === "undefined" ? Object : Date)
], IdentityEntity.prototype, "lastUpdatedAt", void 0);
_ts_decorate11([
  ManyToOne7(() => PartyEntity, (party) => party.identities, {
    onDelete: "CASCADE"
  }),
  _ts_metadata10("design:type", typeof PartyEntity === "undefined" ? Object : PartyEntity)
], IdentityEntity.prototype, "party", void 0);
_ts_decorate11([
  Column9("text", {
    name: "partyId",
    nullable: true
  }),
  _ts_metadata10("design:type", String)
], IdentityEntity.prototype, "partyId", void 0);
_ts_decorate11([
  BeforeInsert10(),
  BeforeUpdate10(),
  _ts_metadata10("design:type", Function),
  _ts_metadata10("design:paramtypes", []),
  _ts_metadata10("design:returntype", void 0)
], IdentityEntity.prototype, "updateUpdatedDate", null);
_ts_decorate11([
  BeforeInsert10(),
  BeforeUpdate10(),
  _ts_metadata10("design:type", Function),
  _ts_metadata10("design:paramtypes", []),
  _ts_metadata10("design:returntype", Promise)
], IdentityEntity.prototype, "validate", null);
IdentityEntity = _ts_decorate11([
  Entity10("Identity")
], IdentityEntity);

// src/entities/contact/ConnectionEntity.ts
function _ts_decorate12(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_decorate12, "_ts_decorate");
function _ts_metadata11(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata11, "_ts