@sphereon/ssi-sdk.data-store 0.23.5-unstable.88 → 0.24.0

package/src/__tests__/machineState.entities.test.ts

@@ -1,51 +1,51 @@
-import { DataSource } from 'typeorm'
-import { MachineStateInfoEntity } from '../entities/machineState/MachineStateInfoEntity'
-
-import { DataStoreMachineStateEntities, DataStoreMachineStateMigrations, StoreMachineStatePersistArgs, MachineStateStore } from '../index'
-
-describe('Machine State Info Database entities tests', (): void => {
-  let dbConnection: DataSource
-
-  beforeEach(async (): Promise<void> => {
-    dbConnection = await new DataSource({
-      type: 'sqlite',
-      database: ':memory:',
-      //logging: 'all',
-      migrationsRun: false,
-      migrations: DataStoreMachineStateMigrations,
-      synchronize: false,
-      entities: [...DataStoreMachineStateEntities],
-    }).initialize()
-    await dbConnection.runMigrations()
-    expect(await dbConnection.showMigrations()).toBeFalsy()
-  })
-
-  afterEach(async (): Promise<void> => {
-    await dbConnection.destroy()
-  })
-
-  it('should save machine state info to database', async (): Promise<void> => {
-    const expiresAt = new Date()
-    expiresAt.setTime(expiresAt.getTime() + 100000)
-    const machineInfo: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      latestStateName: 'acceptAgreement',
-      machineName: 'Onboarding',
-      updatedCount: 0,
-      latestEventType: 'SET_TOC',
-      state: JSON.stringify({ myState: 'test_state' }),
-      tenantId: 'test_tenant_id',
-      expiresAt,
-    }
-    const fromDb: MachineStateInfoEntity = await dbConnection
-      .getRepository(MachineStateInfoEntity)
-      .save(MachineStateStore.machineStateInfoEntityFrom(machineInfo))
-
-    expect(fromDb).toBeDefined()
-    expect(fromDb?.instanceId).not.toBeNull()
-    expect(fromDb?.machineName).toEqual(machineInfo.machineName)
-    expect(fromDb?.state).toEqual(machineInfo.state)
-    expect(fromDb?.tenantId).toEqual(machineInfo.tenantId)
-    expect(fromDb?.completedAt).toBeNull()
-  })
-})
+import { DataSource } from 'typeorm'
+import { MachineStateInfoEntity } from '../entities/machineState/MachineStateInfoEntity'
+
+import { DataStoreMachineStateEntities, DataStoreMachineStateMigrations, StoreMachineStatePersistArgs, MachineStateStore } from '../index'
+
+describe('Machine State Info Database entities tests', (): void => {
+  let dbConnection: DataSource
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      //logging: 'all',
+      migrationsRun: false,
+      migrations: DataStoreMachineStateMigrations,
+      synchronize: false,
+      entities: [...DataStoreMachineStateEntities],
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+  })
+
+  afterEach(async (): Promise<void> => {
+    await dbConnection.destroy()
+  })
+
+  it('should save machine state info to database', async (): Promise<void> => {
+    const expiresAt = new Date()
+    expiresAt.setTime(expiresAt.getTime() + 100000)
+    const machineInfo: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      latestStateName: 'acceptAgreement',
+      machineName: 'Onboarding',
+      updatedCount: 0,
+      latestEventType: 'SET_TOC',
+      state: JSON.stringify({ myState: 'test_state' }),
+      tenantId: 'test_tenant_id',
+      expiresAt,
+    }
+    const fromDb: MachineStateInfoEntity = await dbConnection
+      .getRepository(MachineStateInfoEntity)
+      .save(MachineStateStore.machineStateInfoEntityFrom(machineInfo))
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.instanceId).not.toBeNull()
+    expect(fromDb?.machineName).toEqual(machineInfo.machineName)
+    expect(fromDb?.state).toEqual(machineInfo.state)
+    expect(fromDb?.tenantId).toEqual(machineInfo.tenantId)
+    expect(fromDb?.completedAt).toBeNull()
+  })
+})

package/src/__tests__/machineState.store.test.ts

@@ -1,174 +1,174 @@
-import { DataSource } from 'typeorm'
-import { DataStoreMachineStateEntities, MachineStateStore, StoreMachineStatesFindActiveArgs, StoreMachineStatePersistArgs } from '../index'
-import { DataStoreMachineStateMigrations } from '../migrations'
-
-describe('Machine State store tests', (): void => {
-  let dbConnection: DataSource
-  let store: MachineStateStore
-
-  beforeEach(async (): Promise<void> => {
-    dbConnection = await new DataSource({
-      type: 'sqlite',
-      database: ':memory:',
-      logging: 'all',
-      migrationsRun: false,
-      migrations: DataStoreMachineStateMigrations,
-      synchronize: false,
-      entities: DataStoreMachineStateEntities,
-    }).initialize()
-    await dbConnection.runMigrations()
-    expect(await dbConnection.showMigrations()).toBeFalsy()
-    store = new MachineStateStore(dbConnection)
-  })
-
-  afterEach(async (): Promise<void> => {
-    await dbConnection.destroy()
-  })
-
-  it('should store machine state info', async (): Promise<void> => {
-    const persistArgs: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      machineName: 'Onboarding',
-      updatedCount: 0,
-      latestStateName: 'enterPersonalDetails',
-      latestEventType: 'SET_PERSONAL_DATA',
-      state: 'test_state',
-      expiresAt: new Date(new Date().getDate() + 100000),
-      tenantId: 'test_tenant_id',
-    }
-
-    const persistMachineStateResult = await store.persistMachineState(persistArgs)
-    expect(persistMachineStateResult).toBeDefined()
-  })
-
-  it('should get all machines with their current state', async (): Promise<void> => {
-    const persistArgs: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      machineName: 'Onboarding',
-      latestStateName: 'enterPersonalDetails',
-      latestEventType: 'SET_PERSONAL_DATA',
-      updatedCount: 0,
-      state: 'test_state',
-      expiresAt: new Date(new Date().getDate() + 100000),
-      tenantId: 'test_tenant_id',
-    }
-
-    const stateEvent1 = await store.persistMachineState({ ...persistArgs })
-    expect(stateEvent1).toBeDefined()
-
-    const stateEvent2 = await store.persistMachineState({ ...persistArgs, instanceId: 'Onboarding2' })
-    expect(stateEvent2).toBeDefined()
-
-    const result = await store.findMachineStates()
-    expect(result).toHaveLength(2)
-  })
-
-  it('should retrieve a machine state', async (): Promise<void> => {
-    const expiresAt = new Date()
-    expiresAt.setTime(expiresAt.getTime() + 100000)
-    const persistArgs: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      machineName: 'Onboarding',
-      latestStateName: 'enterPersonalDetails',
-      latestEventType: 'SET_PERSONAL_DATA',
-      state: 'test_state',
-      updatedCount: 0,
-      expiresAt,
-      tenantId: 'test_tenant_id',
-    }
-
-    const machineStatePersisted = await store.persistMachineState(persistArgs)
-    expect(machineStatePersisted).toBeDefined()
-    const result = await store.findActiveMachineStates({ machineName: persistArgs.machineName, tenantId: persistArgs.tenantId })
-    expect(result).toBeDefined()
-  })
-
-  it('should delete a machine state', async (): Promise<void> => {
-    const persistArgs: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      machineName: 'Onboarding',
-      updatedCount: 0,
-      latestStateName: 'enterPersonalDetails',
-      latestEventType: 'SET_PERSONAL_DATA',
-      state: 'test_state',
-      expiresAt: new Date(new Date().getDate() + 100000),
-      tenantId: 'test_tenant_id',
-    }
-
-    const persistedState = await store.persistMachineState(persistArgs)
-    expect(persistedState).toBeDefined()
-
-    const result: boolean = await store.deleteMachineState({ instanceId: persistedState.instanceId })
-    expect(result).toBeTruthy()
-  })
-
-  it('should return an error if type filter does not match', async (): Promise<void> => {
-    const args: StoreMachineStatesFindActiveArgs = {
-      machineName: 'unknown_machine',
-    }
-
-    await expect(store.findActiveMachineStates(args)).resolves.toEqual([])
-  })
-
-  it('should delete the expired records', async () => {
-    const futureExpiresAt = new Date()
-    futureExpiresAt.setTime(futureExpiresAt.getTime() + 100000) // Future expiration
-
-    const pastExpiresAt = new Date()
-    pastExpiresAt.setTime(pastExpiresAt.getTime() - 100000) // Past expiration, already expired
-
-    const oldestXstateEvent: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      machineName: 'Onboarding',
-      latestStateName: 'enterPersonalDetails',
-      latestEventType: 'SET_TOC',
-      updatedCount: 0,
-      state: 'test_state',
-      expiresAt: futureExpiresAt,
-      tenantId: 'test_tenant_id',
-    }
-    const middleXstateEvent: StoreMachineStatePersistArgs = {
-      instanceId: 'Onboarding1',
-      machineName: 'Onboarding',
-      latestStateName: 'TOC',
-      latestEventType: 'SET_POLICY2',
-      updatedCount: 1,
-      state: 'test_state',
-      expiresAt: futureExpiresAt,
-      tenantId: 'test_tenant_id',
-    }
-    const newestXstateEvent: StoreMachineStatePersistArgs = {
-      instanceId: 'OnboardingExpired',
-      machineName: 'Onboarding',
-      latestStateName: 'POLICY',
-      latestEventType: 'SET_PERSONAL_DATA',
-      updatedCount: 0,
-      state: 'test_state',
-      expiresAt: pastExpiresAt, // This event should be already expired
-      tenantId: 'test_tenant_id',
-    }
-
-    await store.persistMachineState(oldestXstateEvent)
-    await store.persistMachineState(middleXstateEvent)
-    await store.persistMachineState(newestXstateEvent)
-
-    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toHaveLength(1)
-
-    await store.deleteExpiredMachineStates({})
-    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toHaveLength(1)
-    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toMatchObject([
-      {
-        completedAt: null,
-        createdAt: expect.anything(),
-        expiresAt: expect.anything(),
-        instanceId: 'Onboarding1',
-        latestEventType: 'SET_POLICY2',
-        latestStateName: 'TOC',
-        machineName: 'Onboarding',
-        state: 'test_state',
-        tenantId: 'test_tenant_id',
-        updatedAt: expect.anything(),
-      },
-    ])
-  })
-})
+import { DataSource } from 'typeorm'
+import { DataStoreMachineStateEntities, MachineStateStore, StoreMachineStatesFindActiveArgs, StoreMachineStatePersistArgs } from '../index'
+import { DataStoreMachineStateMigrations } from '../migrations'
+
+describe('Machine State store tests', (): void => {
+  let dbConnection: DataSource
+  let store: MachineStateStore
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      logging: 'all',
+      migrationsRun: false,
+      migrations: DataStoreMachineStateMigrations,
+      synchronize: false,
+      entities: DataStoreMachineStateEntities,
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+    store = new MachineStateStore(dbConnection)
+  })
+
+  afterEach(async (): Promise<void> => {
+    await dbConnection.destroy()
+  })
+
+  it('should store machine state info', async (): Promise<void> => {
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      updatedCount: 0,
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const persistMachineStateResult = await store.persistMachineState(persistArgs)
+    expect(persistMachineStateResult).toBeDefined()
+  })
+
+  it('should get all machines with their current state', async (): Promise<void> => {
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      updatedCount: 0,
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const stateEvent1 = await store.persistMachineState({ ...persistArgs })
+    expect(stateEvent1).toBeDefined()
+
+    const stateEvent2 = await store.persistMachineState({ ...persistArgs, instanceId: 'Onboarding2' })
+    expect(stateEvent2).toBeDefined()
+
+    const result = await store.findMachineStates()
+    expect(result).toHaveLength(2)
+  })
+
+  it('should retrieve a machine state', async (): Promise<void> => {
+    const expiresAt = new Date()
+    expiresAt.setTime(expiresAt.getTime() + 100000)
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      updatedCount: 0,
+      expiresAt,
+      tenantId: 'test_tenant_id',
+    }
+
+    const machineStatePersisted = await store.persistMachineState(persistArgs)
+    expect(machineStatePersisted).toBeDefined()
+    const result = await store.findActiveMachineStates({ machineName: persistArgs.machineName, tenantId: persistArgs.tenantId })
+    expect(result).toBeDefined()
+  })
+
+  it('should delete a machine state', async (): Promise<void> => {
+    const persistArgs: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      updatedCount: 0,
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_PERSONAL_DATA',
+      state: 'test_state',
+      expiresAt: new Date(new Date().getDate() + 100000),
+      tenantId: 'test_tenant_id',
+    }
+
+    const persistedState = await store.persistMachineState(persistArgs)
+    expect(persistedState).toBeDefined()
+
+    const result: boolean = await store.deleteMachineState({ instanceId: persistedState.instanceId })
+    expect(result).toBeTruthy()
+  })
+
+  it('should return an error if type filter does not match', async (): Promise<void> => {
+    const args: StoreMachineStatesFindActiveArgs = {
+      machineName: 'unknown_machine',
+    }
+
+    await expect(store.findActiveMachineStates(args)).resolves.toEqual([])
+  })
+
+  it('should delete the expired records', async () => {
+    const futureExpiresAt = new Date()
+    futureExpiresAt.setTime(futureExpiresAt.getTime() + 100000) // Future expiration
+
+    const pastExpiresAt = new Date()
+    pastExpiresAt.setTime(pastExpiresAt.getTime() - 100000) // Past expiration, already expired
+
+    const oldestXstateEvent: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'enterPersonalDetails',
+      latestEventType: 'SET_TOC',
+      updatedCount: 0,
+      state: 'test_state',
+      expiresAt: futureExpiresAt,
+      tenantId: 'test_tenant_id',
+    }
+    const middleXstateEvent: StoreMachineStatePersistArgs = {
+      instanceId: 'Onboarding1',
+      machineName: 'Onboarding',
+      latestStateName: 'TOC',
+      latestEventType: 'SET_POLICY2',
+      updatedCount: 1,
+      state: 'test_state',
+      expiresAt: futureExpiresAt,
+      tenantId: 'test_tenant_id',
+    }
+    const newestXstateEvent: StoreMachineStatePersistArgs = {
+      instanceId: 'OnboardingExpired',
+      machineName: 'Onboarding',
+      latestStateName: 'POLICY',
+      latestEventType: 'SET_PERSONAL_DATA',
+      updatedCount: 0,
+      state: 'test_state',
+      expiresAt: pastExpiresAt, // This event should be already expired
+      tenantId: 'test_tenant_id',
+    }
+
+    await store.persistMachineState(oldestXstateEvent)
+    await store.persistMachineState(middleXstateEvent)
+    await store.persistMachineState(newestXstateEvent)
+
+    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toHaveLength(1)
+
+    await store.deleteExpiredMachineStates({})
+    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toHaveLength(1)
+    await expect(store.findActiveMachineStates({ machineName: 'Onboarding' })).resolves.toMatchObject([
+      {
+        completedAt: null,
+        createdAt: expect.anything(),
+        expiresAt: expect.anything(),
+        instanceId: 'Onboarding1',
+        latestEventType: 'SET_POLICY2',
+        latestStateName: 'TOC',
+        machineName: 'Onboarding',
+        state: 'test_state',
+        tenantId: 'test_tenant_id',
+        updatedAt: expect.anything(),
+      },
+    ])
+  })
+})

package/src/contact/AbstractContactStore.ts

@@ -1,71 +1,71 @@
-import {
-  AddElectronicAddressArgs,
-  AddIdentityArgs,
-  AddPartyArgs,
-  AddPartyTypeArgs,
-  AddPhysicalAddressArgs,
-  AddRelationshipArgs,
-  ElectronicAddress,
-  GetElectronicAddressArgs,
-  GetElectronicAddressesArgs,
-  GetIdentitiesArgs,
-  GetIdentityArgs,
-  GetPartiesArgs,
-  GetPartyArgs,
-  GetPartyTypeArgs,
-  GetPartyTypesArgs,
-  GetPhysicalAddressArgs,
-  GetPhysicalAddressesArgs,
-  GetRelationshipArgs,
-  GetRelationshipsArgs,
-  Identity,
-  Party,
-  PartyRelationship,
-  PartyType,
-  PhysicalAddress,
-  RemoveElectronicAddressArgs,
-  RemoveIdentityArgs,
-  RemovePartyArgs,
-  RemovePartyTypeArgs,
-  RemovePhysicalAddressArgs,
-  RemoveRelationshipArgs,
-  UpdateElectronicAddressArgs,
-  UpdateIdentityArgs,
-  UpdatePartyArgs,
-  UpdatePartyTypeArgs,
-  UpdatePhysicalAddressArgs,
-  UpdateRelationshipArgs,
-} from '../types'
-
-export abstract class AbstractContactStore {
-  abstract getParty(args: GetPartyArgs): Promise<Party>
-  abstract getParties(args?: GetPartiesArgs): Promise<Array<Party>>
-  abstract addParty(args: AddPartyArgs): Promise<Party>
-  abstract updateParty(args: UpdatePartyArgs): Promise<Party>
-  abstract removeParty(args: RemovePartyArgs): Promise<void>
-  abstract getIdentity(args: GetIdentityArgs): Promise<Identity>
-  abstract getIdentities(args?: GetIdentitiesArgs): Promise<Array<Identity>>
-  abstract addIdentity(args: AddIdentityArgs): Promise<Identity>
-  abstract updateIdentity(args: UpdateIdentityArgs): Promise<Identity>
-  abstract removeIdentity(args: RemoveIdentityArgs): Promise<void>
-  abstract getRelationship(args: GetRelationshipArgs): Promise<PartyRelationship>
-  abstract getRelationships(args?: GetRelationshipsArgs): Promise<Array<PartyRelationship>>
-  abstract addRelationship(args: AddRelationshipArgs): Promise<PartyRelationship>
-  abstract updateRelationship(args: UpdateRelationshipArgs): Promise<PartyRelationship>
-  abstract removeRelationship(args: RemoveRelationshipArgs): Promise<void>
-  abstract getPartyType(args: GetPartyTypeArgs): Promise<PartyType>
-  abstract getPartyTypes(args?: GetPartyTypesArgs): Promise<Array<PartyType>>
-  abstract addPartyType(args: AddPartyTypeArgs): Promise<PartyType>
-  abstract updatePartyType(args: UpdatePartyTypeArgs): Promise<PartyType>
-  abstract removePartyType(args: RemovePartyTypeArgs): Promise<void>
-  abstract getElectronicAddress(args: GetElectronicAddressArgs): Promise<ElectronicAddress>
-  abstract getElectronicAddresses(args?: GetElectronicAddressesArgs): Promise<Array<ElectronicAddress>>
-  abstract addElectronicAddress(args: AddElectronicAddressArgs): Promise<ElectronicAddress>
-  abstract updateElectronicAddress(args: UpdateElectronicAddressArgs): Promise<ElectronicAddress>
-  abstract removeElectronicAddress(args: RemoveElectronicAddressArgs): Promise<void>
-  abstract getPhysicalAddress(args: GetPhysicalAddressArgs): Promise<PhysicalAddress>
-  abstract getPhysicalAddresses(args?: GetPhysicalAddressesArgs): Promise<Array<PhysicalAddress>>
-  abstract addPhysicalAddress(args: AddPhysicalAddressArgs): Promise<PhysicalAddress>
-  abstract updatePhysicalAddress(args: UpdatePhysicalAddressArgs): Promise<PhysicalAddress>
-  abstract removePhysicalAddress(args: RemovePhysicalAddressArgs): Promise<void>
-}
+import {
+  AddElectronicAddressArgs,
+  AddIdentityArgs,
+  AddPartyArgs,
+  AddPartyTypeArgs,
+  AddPhysicalAddressArgs,
+  AddRelationshipArgs,
+  ElectronicAddress,
+  GetElectronicAddressArgs,
+  GetElectronicAddressesArgs,
+  GetIdentitiesArgs,
+  GetIdentityArgs,
+  GetPartiesArgs,
+  GetPartyArgs,
+  GetPartyTypeArgs,
+  GetPartyTypesArgs,
+  GetPhysicalAddressArgs,
+  GetPhysicalAddressesArgs,
+  GetRelationshipArgs,
+  GetRelationshipsArgs,
+  Identity,
+  Party,
+  PartyRelationship,
+  PartyType,
+  PhysicalAddress,
+  RemoveElectronicAddressArgs,
+  RemoveIdentityArgs,
+  RemovePartyArgs,
+  RemovePartyTypeArgs,
+  RemovePhysicalAddressArgs,
+  RemoveRelationshipArgs,
+  UpdateElectronicAddressArgs,
+  UpdateIdentityArgs,
+  UpdatePartyArgs,
+  UpdatePartyTypeArgs,
+  UpdatePhysicalAddressArgs,
+  UpdateRelationshipArgs,
+} from '../types'
+
+export abstract class AbstractContactStore {
+  abstract getParty(args: GetPartyArgs): Promise<Party>
+  abstract getParties(args?: GetPartiesArgs): Promise<Array<Party>>
+  abstract addParty(args: AddPartyArgs): Promise<Party>
+  abstract updateParty(args: UpdatePartyArgs): Promise<Party>
+  abstract removeParty(args: RemovePartyArgs): Promise<void>
+  abstract getIdentity(args: GetIdentityArgs): Promise<Identity>
+  abstract getIdentities(args?: GetIdentitiesArgs): Promise<Array<Identity>>
+  abstract addIdentity(args: AddIdentityArgs): Promise<Identity>
+  abstract updateIdentity(args: UpdateIdentityArgs): Promise<Identity>
+  abstract removeIdentity(args: RemoveIdentityArgs): Promise<void>
+  abstract getRelationship(args: GetRelationshipArgs): Promise<PartyRelationship>
+  abstract getRelationships(args?: GetRelationshipsArgs): Promise<Array<PartyRelationship>>
+  abstract addRelationship(args: AddRelationshipArgs): Promise<PartyRelationship>
+  abstract updateRelationship(args: UpdateRelationshipArgs): Promise<PartyRelationship>
+  abstract removeRelationship(args: RemoveRelationshipArgs): Promise<void>
+  abstract getPartyType(args: GetPartyTypeArgs): Promise<PartyType>
+  abstract getPartyTypes(args?: GetPartyTypesArgs): Promise<Array<PartyType>>
+  abstract addPartyType(args: AddPartyTypeArgs): Promise<PartyType>
+  abstract updatePartyType(args: UpdatePartyTypeArgs): Promise<PartyType>
+  abstract removePartyType(args: RemovePartyTypeArgs): Promise<void>
+  abstract getElectronicAddress(args: GetElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract getElectronicAddresses(args?: GetElectronicAddressesArgs): Promise<Array<ElectronicAddress>>
+  abstract addElectronicAddress(args: AddElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract updateElectronicAddress(args: UpdateElectronicAddressArgs): Promise<ElectronicAddress>
+  abstract removeElectronicAddress(args: RemoveElectronicAddressArgs): Promise<void>
+  abstract getPhysicalAddress(args: GetPhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract getPhysicalAddresses(args?: GetPhysicalAddressesArgs): Promise<Array<PhysicalAddress>>
+  abstract addPhysicalAddress(args: AddPhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract updatePhysicalAddress(args: UpdatePhysicalAddressArgs): Promise<PhysicalAddress>
+  abstract removePhysicalAddress(args: RemovePhysicalAddressArgs): Promise<void>
+}