@sphereon/ssi-sdk.data-store 0.34.1-feature.FIDES.1.274 → 0.34.1-feature.IDK.11.49

package/src/presentationDefinition/PDStore.ts

@@ -1,20 +1,20 @@
+import { type OrPromise } from '@sphereon/ssi-types'
+import { DataSource, In, Repository } from 'typeorm'
+import { AbstractPDStore } from './AbstractPDStore'
+import Debug from 'debug'
 import type {
-  DcqlQueryItem,
-  DcqlQueryItemFilter,
   DeleteDefinitionArgs,
   DeleteDefinitionsArgs,
   GetDefinitionArgs,
   GetDefinitionsArgs,
   HasDefinitionArgs,
   HasDefinitionsArgs,
-  NonPersistedDcqlQueryItem,
-} from '@sphereon/ssi-sdk.data-store-types'
-import { AbstractPDStore } from '@sphereon/ssi-sdk.data-store-types'
-import { type OrPromise } from '@sphereon/ssi-types'
-import Debug from 'debug'
-import { DataSource, In, Repository } from 'typeorm'
-import { DcqlQueryItemEntity } from '../entities/presentationDefinition/DcqlQueryItemEntity'
-import { dcqlQueryEntityItemFrom, dcqlQueryItemFrom } from '../utils/presentationDefinition/MappingUtils'
+  NonPersistedPresentationDefinitionItem,
+  PresentationDefinitionItem,
+  PresentationDefinitionItemFilter,
+} from '../types'
+import { PresentationDefinitionItemEntity } from '../entities/presentationDefinition/PresentationDefinitionItemEntity'
+import { presentationDefinitionEntityItemFrom, presentationDefinitionItemFrom } from '../utils/presentationDefinition/MappingUtils'
 
 const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:pd-store')
 
@@ -26,22 +26,22 @@ export class PDStore extends AbstractPDStore {
     this.dbConnection = dbConnection
   }
 
-  getDefinition = async (args: GetDefinitionArgs): Promise<DcqlQueryItem> => {
+  getDefinition = async (args: GetDefinitionArgs): Promise<PresentationDefinitionItem> => {
     const { itemId } = args ?? {}
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
-    const result: DcqlQueryItemEntity | null = await pdRepository.findOne({
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const result: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
       where: { id: itemId },
     })
     if (!result) {
       return Promise.reject(Error(`No presentation definition item found for id: ${itemId}`))
     }
 
-    return dcqlQueryItemFrom(result)
+    return presentationDefinitionItemFrom(result)
   }
 
   hasDefinition = async (args: HasDefinitionArgs): Promise<boolean> => {
     const { itemId } = args ?? {}
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
     const resultCount: number = await pdRepository.count({
       where: { id: itemId },
@@ -52,7 +52,7 @@ export class PDStore extends AbstractPDStore {
 
   hasDefinitions = async (args: HasDefinitionsArgs): Promise<boolean> => {
     const { filter } = args
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
     const resultCount: number = await pdRepository.count({
       ...(filter && { where: cleanFilter(filter) }),
@@ -60,67 +60,67 @@ export class PDStore extends AbstractPDStore {
     return resultCount > 0
   }
 
-  getDefinitions = async (args: GetDefinitionsArgs): Promise<Array<DcqlQueryItem>> => {
+  getDefinitions = async (args: GetDefinitionsArgs): Promise<Array<PresentationDefinitionItem>> => {
     const { filter } = args
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
     const initialResult = await this.findIds(pdRepository, filter)
-    const result: Array<DcqlQueryItemEntity> = await pdRepository.find({
+    const result: Array<PresentationDefinitionItemEntity> = await pdRepository.find({
       where: {
-        id: In(initialResult.map((entity: DcqlQueryItemEntity) => entity.id)),
+        id: In(initialResult.map((entity: PresentationDefinitionItemEntity) => entity.id)),
       },
       order: {
         version: 'DESC',
       },
     })
 
-    return result.map((entity: DcqlQueryItemEntity) => dcqlQueryItemFrom(entity))
+    return result.map((entity: PresentationDefinitionItemEntity) => presentationDefinitionItemFrom(entity))
   }
 
-  addDefinition = async (item: NonPersistedDcqlQueryItem): Promise<DcqlQueryItem> => {
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+  addDefinition = async (item: NonPersistedPresentationDefinitionItem): Promise<PresentationDefinitionItem> => {
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
-    const entity: DcqlQueryItemEntity = dcqlQueryEntityItemFrom(item)
+    const entity: PresentationDefinitionItemEntity = presentationDefinitionEntityItemFrom(item)
     debug('Adding presentation definition entity', item)
-    const result: DcqlQueryItemEntity = await pdRepository.save(entity, {
+    const result: PresentationDefinitionItemEntity = await pdRepository.save(entity, {
       transaction: true,
     })
 
-    return dcqlQueryItemFrom(result)
+    return presentationDefinitionItemFrom(result)
   }
 
-  updateDefinition = async (item: DcqlQueryItem): Promise<DcqlQueryItem> => {
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+  updateDefinition = async (item: PresentationDefinitionItem): Promise<PresentationDefinitionItem> => {
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
 
-    const result: DcqlQueryItemEntity | null = await pdRepository.findOne({
+    const result: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
       where: { id: item.id },
     })
     if (!result) {
       return Promise.reject(Error(`No presentation definition entity found for id: ${item.id}`))
     }
 
-    const updatedEntity: Partial<DcqlQueryItemEntity> = {
+    const updatedEntity: Partial<PresentationDefinitionItemEntity> = {
       ...result,
     }
     updatedEntity.tenantId = item.tenantId
-    updatedEntity.queryId = item.queryId!
+    updatedEntity.definitionId = item.definitionId!
     updatedEntity.version = item.version
     updatedEntity.name = item.name
     updatedEntity.purpose = item.purpose
-    updatedEntity.query = JSON.stringify(item.query)
+    updatedEntity.definitionPayload = JSON.stringify(item.definitionPayload!)
 
     debug('Updating presentation definition entity', updatedEntity)
-    const updateResult: DcqlQueryItemEntity = await pdRepository.save(updatedEntity, {
+    const updateResult: PresentationDefinitionItemEntity = await pdRepository.save(updatedEntity, {
       transaction: true,
     })
 
-    return dcqlQueryItemFrom(updateResult)
+    return presentationDefinitionItemFrom(updateResult)
   }
 
   deleteDefinition = async (args: DeleteDefinitionArgs): Promise<void> => {
     const { itemId } = args
 
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
-    const entity: DcqlQueryItemEntity | null = await pdRepository.findOne({
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
+    const entity: PresentationDefinitionItemEntity | null = await pdRepository.findOne({
       where: { id: itemId },
     })
 
@@ -134,12 +134,12 @@ export class PDStore extends AbstractPDStore {
 
   deleteDefinitions = async (args: DeleteDefinitionsArgs): Promise<number> => {
     const { filter } = args
-    const pdRepository = (await this.dbConnection).getRepository(DcqlQueryItemEntity)
+    const pdRepository = (await this.dbConnection).getRepository(PresentationDefinitionItemEntity)
     const initialResult = await this.findIds(pdRepository, filter)
 
-    const result: Array<DcqlQueryItemEntity> = await pdRepository.find({
+    const result: Array<PresentationDefinitionItemEntity> = await pdRepository.find({
       where: {
-        id: In(initialResult.map((entity: DcqlQueryItemEntity) => entity.id)),
+        id: In(initialResult.map((entity: PresentationDefinitionItemEntity) => entity.id)),
       },
     })
 
@@ -151,9 +151,9 @@ export class PDStore extends AbstractPDStore {
   }
 
   findIds = async (
-    pdRepository: Repository<DcqlQueryItemEntity>,
-    filter: Array<DcqlQueryItemFilter> | undefined,
-  ): Promise<Array<DcqlQueryItemEntity>> => {
+    pdRepository: Repository<PresentationDefinitionItemEntity>,
+    filter: Array<PresentationDefinitionItemFilter> | undefined,
+  ): Promise<Array<PresentationDefinitionItemEntity>> => {
     const idFilters = filter?.map((f) => f.id).filter((id) => id !== undefined && id !== null)
     if (idFilters && idFilters.length > 0 && idFilters.length === filter?.length) {
       return await pdRepository.find({
@@ -167,15 +167,15 @@ export class PDStore extends AbstractPDStore {
   }
 }
 
-const cleanFilter = (filter: Array<DcqlQueryItemFilter> | undefined): Array<DcqlQueryItemFilter> | undefined => {
+const cleanFilter = (filter: Array<PresentationDefinitionItemFilter> | undefined): Array<PresentationDefinitionItemFilter> | undefined => {
   if (filter === undefined) {
     return undefined
   }
 
   return filter.map((item) => {
-    const cleanedItem: DcqlQueryItemFilter = {}
+    const cleanedItem: PresentationDefinitionItemFilter = {}
     for (const key in item) {
-      const value = item[key as keyof DcqlQueryItemFilter]
+      const value = item[key as keyof PresentationDefinitionItemFilter]
       if (value !== undefined) {
         ;(cleanedItem as any)[key] = value
       }

package/src/statusList/IStatusListStore.ts

@@ -1,4 +1,3 @@
-import { BitstringStatusListEntryEntity } from '../entities/statusList/BitstringStatusListEntryEntity'
 import { StatusListEntryEntity } from '../entities/statusList/StatusList2021EntryEntity'
 import type {
   IAddStatusListArgs,
@@ -15,6 +14,7 @@ import type {
   IUpdateStatusListIndexArgs,
 } from '../types'
 import { IStatusListEntity, IStatusListEntryEntity } from '../types'
+import { BitstringStatusListEntryEntity } from '../entities/statusList/BitstringStatusListEntryEntity'
 
 export interface IStatusListStore {
   getStatusList(args: IGetStatusListArgs): Promise<IStatusListEntity | IBitstringStatusListEntity>

package/src/statusList/StatusListStore.ts

@@ -1,9 +1,9 @@
 import { type OrPromise, StatusListType } from '@sphereon/ssi-types'
 import Debug from 'debug'
 import { DataSource, In, type Repository } from 'typeorm'
-import { BitstringStatusListEntryEntity } from '../entities/statusList/BitstringStatusListEntryEntity'
-import { StatusListEntryEntity } from '../entities/statusList/StatusList2021EntryEntity'
 import { BitstringStatusListEntity, OAuthStatusListEntity, StatusList2021Entity, StatusListEntity } from '../entities/statusList/StatusListEntities'
+import { StatusListEntryEntity } from '../entities/statusList/StatusList2021EntryEntity'
+import { BitstringStatusListEntryEntity } from '../entities/statusList/BitstringStatusListEntryEntity'
 import {
   IAddStatusListArgs,
   IAddStatusListEntryArgs,
@@ -20,8 +20,8 @@ import {
   IStatusListEntryEntity,
   IUpdateStatusListIndexArgs,
 } from '../types'
-import { statusListEntityFrom, statusListFrom } from '../utils/statusList/MappingUtils'
 import type { IStatusListStore } from './IStatusListStore'
+import { statusListEntityFrom, statusListFrom } from '../utils/statusList/MappingUtils'
 
 const debug = Debug('sphereon:ssi-sdk:data-store:status-list')
 

package/src/types/contact/IAbstractContactStore.ts

@@ -0,0 +1,161 @@
+import {
+  ElectronicAddress,
+  Identity,
+  NonPersistedContact,
+  NonPersistedElectronicAddress,
+  NonPersistedIdentity,
+  NonPersistedPartyType,
+  NonPersistedPhysicalAddress,
+  PartialElectronicAddress,
+  PartialIdentity,
+  PartialParty,
+  PartialPartyRelationship,
+  PartialPartyType,
+  PartialPhysicalAddress,
+  Party,
+  PartyOrigin,
+  PartyRelationship,
+  PartyType,
+  PartyTypeType,
+  PhysicalAddress,
+} from './contact'
+
+export type FindPartyArgs = Array<PartialParty>
+export type FindIdentityArgs = Array<PartialIdentity>
+export type FindPartyTypeArgs = Array<PartialPartyType>
+export type FindRelationshipArgs = Array<PartialPartyRelationship>
+export type FindElectronicAddressArgs = Array<PartialElectronicAddress>
+export type FindPhysicalAddressArgs = Array<PartialPhysicalAddress>
+
+export type GetPartyArgs = {
+  partyId: string
+}
+
+export type GetPartiesArgs = {
+  filter?: FindPartyArgs
+}
+
+export type AddPartyArgs = {
+  uri?: string
+  partyType: NonPersistedPartyType
+  contact: NonPersistedContact
+  identities?: Array<NonPersistedIdentity>
+  electronicAddresses?: Array<NonPersistedElectronicAddress>
+  physicalAddresses?: Array<NonPersistedPhysicalAddress>
+}
+
+export type UpdatePartyArgs = {
+  party: Omit<Party, 'identities' | 'electronicAddresses' | 'partyType' | 'createdAt' | 'lastUpdatedAt'>
+}
+
+export type RemovePartyArgs = {
+  partyId: string
+}
+
+export type GetIdentityArgs = {
+  identityId: string
+}
+
+export type GetIdentitiesArgs = {
+  filter?: FindIdentityArgs
+}
+
+export type AddIdentityArgs = {
+  partyId: string
+  identity: NonPersistedIdentity
+}
+
+export type UpdateIdentityArgs = {
+  identity: Identity
+}
+
+export type RemoveIdentityArgs = {
+  identityId: string
+}
+
+export type RemoveRelationshipArgs = {
+  relationshipId: string
+}
+
+export type AddRelationshipArgs = {
+  leftId: string
+  rightId: string
+}
+
+export type GetRelationshipArgs = {
+  relationshipId: string
+}
+
+export type GetRelationshipsArgs = {
+  filter: FindRelationshipArgs
+}
+
+export type UpdateRelationshipArgs = {
+  relationship: Omit<PartyRelationship, 'createdAt' | 'lastUpdatedAt'>
+}
+
+export type AddPartyTypeArgs = {
+  type: PartyTypeType
+  origin: PartyOrigin
+  name: string
+  tenantId: string
+  description?: string
+}
+
+export type GetPartyTypeArgs = {
+  partyTypeId: string
+}
+
+export type GetPartyTypesArgs = {
+  filter?: FindPartyTypeArgs
+}
+
+export type UpdatePartyTypeArgs = {
+  partyType: Omit<PartyType, 'createdAt' | 'lastUpdatedAt'>
+}
+
+export type RemovePartyTypeArgs = {
+  partyTypeId: string
+}
+
+export type GetElectronicAddressArgs = {
+  electronicAddressId: string
+}
+
+export type GetElectronicAddressesArgs = {
+  filter?: FindElectronicAddressArgs
+}
+
+export type AddElectronicAddressArgs = {
+  partyId: string
+  electronicAddress: NonPersistedElectronicAddress
+}
+
+export type UpdateElectronicAddressArgs = {
+  electronicAddress: ElectronicAddress
+}
+
+export type RemoveElectronicAddressArgs = {
+  electronicAddressId: string
+}
+
+export type GetPhysicalAddressArgs = {
+  physicalAddressId: string
+}
+
+export type GetPhysicalAddressesArgs = {
+  filter?: FindPhysicalAddressArgs
+}
+
+export type AddPhysicalAddressArgs = {
+  partyId: string
+  physicalAddress: NonPersistedPhysicalAddress
+}
+
+export type UpdatePhysicalAddressArgs = {
+  physicalAddress: PhysicalAddress
+}
+
+export type RemovePhysicalAddressArgs = {
+  physicalAddressId: string
+}

package/src/types/contact/contact.ts

@@ -0,0 +1,295 @@
+import { ManagedIdentifierOptsOrResult } from '@sphereon/ssi-sdk-ext.identifier-resolution'
+import { IIdentifier } from '@veramo/core'
+import { IIssuerLocaleBranding } from '../issuanceBranding/issuanceBranding'
+import { CredentialRole } from '../digitalCredential'
+
+export type MetadataTypes = string | number | Date | boolean | undefined
+
+export interface IMetadataEntity {
+  // TODO move to types
+  label: string
+  stringValue?: string
+  numberValue?: number
+  dateValue?: Date
+  boolValue?: boolean
+}
+
+export type Party = {
+  id: string
+  uri?: string
+  roles: Array<CredentialRole>
+  ownerId?: string
+  tenantId?: string
+  identities: Array<Identity>
+  electronicAddresses: Array<ElectronicAddress>
+  physicalAddresses: Array<PhysicalAddress>
+  contact: Contact
+  partyType: PartyType
+  /**
+   * TODO: Integrate branding logic here in the future. What we should do is make the issuance branding plugin part of the contact-manager and retrieve any branding there is.
+   *
+   * Currently, we are only defining the branding type within the SDK without implementing the associated logic. This is because:
+   * 1. We are combining two types from the SSI-SDK to create a new type that will be used across multiple places in the wallets (web & mobile).
+   * 2. While it makes sense to have this combined type in the SDK, the logic to support database connections for these types is complex. The types belong to different modules, and we don't use them together currently.
+   * 3. Implementing the full logic now would require significant changes and cross-module interactions, which we don't have the time to address at present.
+   *
+   * For now, we are defining the type here and will use it in the mobile wallet has the logic for it. This is a temporary solution until we have the resources to integrate the branding logic fully.
+   */
+  branding?: IIssuerLocaleBranding
+  relationships: Array<PartyRelationship>
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedParty = Omit<
+  Party,
+  | 'id'
+  | 'identities'
+  | 'electronicAddresses'
+  | 'physicalAddresses'
+  | 'contact'
+  | 'roles'
+  | 'partyType'
+  | 'relationships'
+  | 'createdAt'
+  | 'lastUpdatedAt'
+> & {
+  identities?: Array<NonPersistedIdentity>
+  electronicAddresses?: Array<NonPersistedElectronicAddress>
+  physicalAddresses?: Array<NonPersistedPhysicalAddress>
+  contact: NonPersistedContact
+  partyType: NonPersistedPartyType
+  relationships?: Array<NonPersistedPartyRelationship>
+}
+export type PartialParty = Partial<
+  Omit<Party, 'identities' | 'electronicAddresses' | 'physicalAddresses' | 'contact' | 'partyType' | 'relationships'>
+> & {
+  identities?: PartialIdentity
+  electronicAddresses?: PartialElectronicAddress
+  physicalAddresses?: PartialPhysicalAddress
+  contact?: PartialContact
+  partyType?: PartialPartyType
+  relationships?: PartialPartyRelationship
+}
+
+export type Identity = {
+  id: string
+  alias: string
+  ownerId?: string
+  tenantId?: string
+  origin: IdentityOrigin
+  roles: Array<CredentialRole>
+  identifier: CorrelationIdentifier
+  connection?: Connection
+  metadata?: Array<MetadataItem<MetadataTypes>>
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedIdentity = Omit<Identity, 'id' | 'identifier' | 'connection' | 'metadata' | 'origin' | 'createdAt' | 'lastUpdatedAt'> & {
+  origin: IdentityOrigin
+  identifier: NonPersistedCorrelationIdentifier
+  connection?: NonPersistedConnection
+  metadata?: Array<NonPersistedMetadataItem<MetadataTypes>>
+}
+export type PartialIdentity = Partial<Omit<Identity, 'identifier' | 'connection' | 'metadata' | 'origin' | 'roles'>> & {
+  identifier?: PartialCorrelationIdentifier
+  connection?: PartialConnection
+  metadata?: PartialMetadataItem<MetadataTypes> // Usage: FindIdentityArgs = Array<PartialIdentity>
+  origin?: IdentityOrigin
+  roles?: CredentialRole
+  partyId?: string
+}
+
+export type MetadataItem<T extends MetadataTypes> = {
+  id: string
+  label: string
+  value: T
+}
+
+export type NonPersistedMetadataItem<T extends MetadataTypes> = Omit<MetadataItem<T>, 'id'>
+export type PartialMetadataItem<T extends MetadataTypes> = Partial<MetadataItem<T>>
+
+export type CorrelationIdentifier = {
+  id: string
+  ownerId?: string
+  tenantId?: string
+  type: CorrelationIdentifierType
+  correlationId: string
+}
+export type NonPersistedCorrelationIdentifier = Omit<CorrelationIdentifier, 'id'>
+export type PartialCorrelationIdentifier = Partial<CorrelationIdentifier>
+
+export type Connection = {
+  id: string
+  ownerId?: string
+  tenantId?: string
+  type: ConnectionType
+  config: ConnectionConfig
+}
+export type NonPersistedConnection = Omit<Connection, 'id' | 'config'> & {
+  config: NonPersistedConnectionConfig
+}
+export type PartialConnection = Partial<Omit<Connection, 'config'>> & {
+  config: PartialConnectionConfig
+}
+
+export type OpenIdConfig = {
+  id: string
+  clientId: string
+  clientSecret: string
+  ownerId?: string
+  tenantId?: string
+  scopes: Array<string>
+  issuer: string
+  redirectUrl: string
+  dangerouslyAllowInsecureHttpRequests: boolean
+  clientAuthMethod: 'basic' | 'post' | undefined
+}
+export type NonPersistedOpenIdConfig = Omit<OpenIdConfig, 'id'>
+export type PartialOpenIdConfig = Partial<OpenIdConfig>
+
+export type DidAuthConfig = {
+  id: string
+  idOpts: ManagedIdentifierOptsOrResult
+  stateId: string
+  ownerId?: string
+  tenantId?: string
+  redirectUrl: string
+  sessionId: string
+}
+export type NonPersistedDidAuthConfig = Omit<DidAuthConfig, 'id'>
+export type PartialDidAuthConfig = Partial<Omit<DidAuthConfig, 'identifier'>> & {
+  identifier: Partial<IIdentifier> // TODO, we need to create partials for sub types in IIdentifier
+}
+
+export type ConnectionConfig = OpenIdConfig | DidAuthConfig
+export type NonPersistedConnectionConfig = NonPersistedDidAuthConfig | NonPersistedOpenIdConfig
+export type PartialConnectionConfig = PartialOpenIdConfig | PartialDidAuthConfig
+
+export type NaturalPerson = {
+  id: string
+  firstName: string
+  lastName: string
+  middleName?: string
+  displayName: string
+  metadata?: Array<MetadataItem<MetadataTypes>>
+  ownerId?: string
+  tenantId?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+
+export type NonPersistedNaturalPerson = Omit<NaturalPerson, 'id' | 'createdAt' | 'lastUpdatedAt'>
+
+export type PartialNaturalPerson = Partial<Omit<NaturalPerson, 'metadata'>> & {
+  metadata?: PartialMetadataItem<MetadataTypes>
+}
+
+export type Organization = {
+  id: string
+  legalName: string
+  displayName: string
+  metadata?: Array<MetadataItem<MetadataTypes>>
+  ownerId?: string
+  tenantId?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedOrganization = Omit<Organization, 'id' | 'createdAt' | 'lastUpdatedAt'>
+export type PartialOrganization = Partial<Omit<Organization, 'metadata'>> & {
+  metadata?: PartialMetadataItem<MetadataTypes>
+}
+
+export type Contact = NaturalPerson | Organization
+export type NonPersistedContact = NonPersistedNaturalPerson | NonPersistedOrganization
+export type PartialContact = PartialNaturalPerson | PartialOrganization
+
+export type PartyType = {
+  id: string
+  type: PartyTypeType
+  origin: PartyOrigin
+  name: string
+  tenantId: string
+  description?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedPartyType = Omit<PartyType, 'id' | 'createdAt' | 'lastUpdatedAt'> & {
+  id?: string
+}
+export type PartialPartyType = Partial<PartyType>
+
+export type PartyRelationship = {
+  id: string
+  leftId: string
+  rightId: string
+  ownerId?: string
+  tenantId?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedPartyRelationship = Omit<PartyRelationship, 'id' | 'createdAt' | 'lastUpdatedAt'>
+export type PartialPartyRelationship = Partial<PartyRelationship>
+
+export type ElectronicAddress = {
+  id: string
+  type: ElectronicAddressType
+  electronicAddress: string
+  ownerId?: string
+  tenantId?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedElectronicAddress = Omit<ElectronicAddress, 'id' | 'createdAt' | 'lastUpdatedAt'>
+export type PartialElectronicAddress = Partial<ElectronicAddress> & {
+  partyId?: string
+}
+
+export type PhysicalAddress = {
+  id: string
+  type: PhysicalAddressType
+  streetName: string
+  streetNumber: string
+  postalCode: string
+  cityName: string
+  provinceName: string
+  countryCode: string
+  buildingName?: string
+  ownerId?: string
+  tenantId?: string
+  createdAt: Date
+  lastUpdatedAt: Date
+}
+export type NonPersistedPhysicalAddress = Omit<PhysicalAddress, 'id' | 'createdAt' | 'lastUpdatedAt'>
+export type PartialPhysicalAddress = Partial<PhysicalAddress> & {
+  partyId?: string
+}
+
+export type ElectronicAddressType = 'email' | 'phone'
+
+export type PhysicalAddressType = 'home' | 'visit' | 'postal'
+
+export enum ConnectionType {
+  OPENID_CONNECT = 'OIDC',
+  SIOPv2 = 'SIOPv2',
+  SIOPv2_OpenID4VP = 'SIOPv2+OpenID4VP',
+}
+
+export enum CorrelationIdentifierType {
+  DID = 'did',
+  URL = 'url',
+}
+
+export enum PartyTypeType {
+  NATURAL_PERSON = 'naturalPerson',
+  ORGANIZATION = 'organization',
+}
+
+export enum PartyOrigin {
+  INTERNAL = 'INTERNAL',
+  EXTERNAL = 'EXTERNAL',
+}
+
+export enum IdentityOrigin {
+  INTERNAL = 'INTERNAL',
+  EXTERNAL = 'EXTERNAL',
+}