@sphereon/ssi-sdk.data-store/dist/index.d.cts

import * as _veramo_data_store from '@veramo/data-store';
export { Entities as VeramoDataStoreEntities, migrations as VeramoDataStoreMigrations } from '@veramo/data-store';
import { BaseEntity, FindOptionsWhere, DataSource, Repository, MigrationInterface, QueryRunner } from 'typeorm';
import { CorrelationIdentifierType, IMetadataEntity, ElectronicAddressType, PartyTypeType, PartyOrigin, PhysicalAddressType, IdentityOrigin, ConnectionType, DigitalCredential, DocumentType, RegulationType, CredentialDocumentFormat, CredentialCorrelationType, CredentialStateType, AbstractContactStore, GetPartyArgs, Party, GetPartiesArgs, AddPartyArgs, UpdatePartyArgs, RemovePartyArgs, GetIdentityArgs, Identity, GetIdentitiesArgs, AddIdentityArgs, UpdateIdentityArgs, RemoveIdentityArgs, AddRelationshipArgs, PartyRelationship, GetRelationshipArgs, GetRelationshipsArgs, UpdateRelationshipArgs, RemoveRelationshipArgs, AddPartyTypeArgs, PartyType, GetPartyTypeArgs, GetPartyTypesArgs, UpdatePartyTypeArgs, RemovePartyTypeArgs, GetElectronicAddressArgs, ElectronicAddress, GetElectronicAddressesArgs, AddElectronicAddressArgs, UpdateElectronicAddressArgs, RemoveElectronicAddressArgs, GetPhysicalAddressArgs, PhysicalAddress, GetPhysicalAddressesArgs, AddPhysicalAddressArgs, UpdatePhysicalAddressArgs, RemovePhysicalAddressArgs, AbstractDigitalCredentialStore, AddCredentialArgs, GetCredentialArgs, GetCredentialsArgs, GetCredentialsResponse, UpdateCredentialArgs, RemoveCredentialArgs, UpdateCredentialStateArgs, AbstractIssuanceBrandingStore, IAddCredentialBrandingArgs, ICredentialBranding, IGetCredentialBrandingArgs, IRemoveCredentialBrandingArgs, IUpdateCredentialBrandingArgs, IAddCredentialLocaleBrandingArgs, IGetCredentialLocaleBrandingArgs, ICredentialLocaleBranding, IRemoveCredentialLocaleBrandingArgs, IUpdateCredentialLocaleBrandingArgs, IAddIssuerBrandingArgs, IIssuerBranding, IGetIssuerBrandingArgs, IRemoveIssuerBrandingArgs, IUpdateIssuerBrandingArgs, IAddIssuerLocaleBrandingArgs, IGetIssuerLocaleBrandingArgs, IIssuerLocaleBranding, IRemoveIssuerLocaleBrandingArgs, IUpdateIssuerLocaleBrandingArgs, AbstractEventLoggerStore, GetAuditEventsArgs, StoreAuditEventArgs, GetActivityEventsArgs, StoreActivityEventArgs, IAbstractMachineStateStore, StoreMachineStatePersistArgs, StoreMachineStateInfo, StoreMachineStatesFindActiveArgs, StoreFindMachineStatesArgs, StoreMachineStateGetArgs, StoreMachineStateDeleteArgs, StoreMachineStateDeleteExpiredArgs, AbstractPDStore, GetDefinitionArgs, DcqlQueryItem, HasDefinitionArgs, HasDefinitionsArgs, GetDefinitionsArgs, NonPersistedDcqlQueryItem, DeleteDefinitionArgs, DeleteDefinitionsArgs, DcqlQueryItemFilter, NonPersistedParty, NonPersistedContact, Contact, NonPersistedNaturalPerson, NonPersistedOrganization, NonPersistedConnection, Connection, NonPersistedCorrelationIdentifier, CorrelationIdentifier, NonPersistedDidAuthConfig, NonPersistedElectronicAddress, NonPersistedPhysicalAddress, NonPersistedIdentity, NonPersistedMetadataItem, MetadataTypes, MetadataItem, NaturalPerson, NonPersistedOpenIdConfig, Organization, NonPersistedPartyRelationship, NonPersistedPartyType, ConnectionConfig, OpenIdConfig, DidAuthConfig, NonPersistedConnectionConfig, NonPersistedDigitalCredential, NonPersistedAuditLoggingEvent, NonPersistedActivityLoggingEvent, ILocaleBranding, IBasicIssuerLocaleBranding, IBasicBackgroundAttributes, IBasicCredentialBranding, IBasicCredentialLocaleBranding, IBasicImageAttributes, IBasicImageDimensions, IBasicIssuerBranding, IBasicTextAttributes, IBasicCredentialClaim, PartialDcqlQueryItem } from '@sphereon/ssi-sdk.data-store-types';
export { AbstractEventLoggerStore } from '@sphereon/ssi-sdk.data-store-types';
import { CredentialRole, LoggingEventType, LogLevel, System, SubSystem, ActionType, ActionSubType, InitiatorType, SystemCorrelationIdType, StatusListType, IIssuer, StatusListDriverType, StatusListCredentialIdMode, CredentialProofFormat, StatusListCredential, StatusListIndexingDirection, StatusPurpose2021, RequireOneOf, ICredentialStatus, OrPromise, OriginalVerifiableCredential, OriginalVerifiablePresentation } from '@sphereon/ssi-types';
import { PartyCorrelationType, CredentialType, AuditLoggingEvent, ActivityLoggingEvent } from '@sphereon/ssi-sdk.core';

declare class CorrelationIdentifierEntity extends BaseEntity {
    id: string;
    type: CorrelationIdentifierType;
    correlationId: string;
    ownerId?: string;
    tenantId?: string;
    identity: IdentityEntity;
    validate(): Promise<void>;
}

declare class IdentityMetadataItemEntity extends BaseEntity implements IMetadataEntity {
    id: string;
    label: string;
    valueType: string;
    stringValue?: string;
    numberValue?: number;
    dateValue?: Date;
    boolValue?: boolean;
    identity: IdentityEntity;
    validate(): Promise<void>;
}

declare class ContactMetadataItemEntity extends BaseEntity implements IMetadataEntity {
    id: string;
    label: string;
    valueType: string;
    stringValue?: string;
    numberValue?: number;
    dateValue?: Date;
    boolValue?: boolean;
    contact: BaseContactEntity;
    validate(): Promise<void>;
}

declare abstract class BaseContactEntity extends BaseEntity {
    id: string;
    createdAt: Date;
    lastUpdatedAt: Date;
    party: PartyEntity;
    metadata: Array<ContactMetadataItemEntity>;
    updateUpdatedDate(): void;
}

declare class ElectronicAddressEntity extends BaseEntity {
    id: string;
    type: ElectronicAddressType;
    electronicAddress: string;
    party: PartyEntity;
    partyId?: string;
    ownerId?: string;
    tenantId?: string;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    validate(): Promise<void>;
}

declare class PartyRelationshipEntity {
    id: string;
    left: PartyEntity;
    leftId: string;
    right: PartyEntity;
    rightId: string;
    ownerId?: string;
    tenantId?: string;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    checkRelationshipSides(): Promise<void>;
}

declare class PartyTypeEntity {
    id: string;
    type: PartyTypeType;
    origin: PartyOrigin;
    name: string;
    description?: string;
    tenantId: string;
    parties: Array<PartyEntity>;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    validate(): Promise<void>;
}

declare class PhysicalAddressEntity extends BaseEntity {
    id: string;
    type: PhysicalAddressType;
    streetName: string;
    streetNumber: string;
    postalCode: string;
    cityName: string;
    provinceName: string;
    countryCode: string;
    buildingName?: string;
    ownerId?: string;
    tenantId?: string;
    party: PartyEntity;
    partyId?: string;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    validate(): Promise<void>;
}

declare class PartyEntity extends BaseEntity {
    id: string;
    uri?: string;
    ownerId?: string;
    tenantId?: string;
    identities: Array<IdentityEntity>;
    electronicAddresses: Array<ElectronicAddressEntity>;
    physicalAddresses: Array<PhysicalAddressEntity>;
    partyType: PartyTypeEntity;
    contact: BaseContactEntity;
    relationships: Array<PartyRelationshipEntity>;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    validate(): Promise<void>;
}

declare class IdentityEntity extends BaseEntity {
    id: string;
    alias: string;
    origin: IdentityOrigin;
    ownerId?: string;
    tenantId?: string;
    roles: Array<CredentialRole>;
    identifier: CorrelationIdentifierEntity;
    connection?: ConnectionEntity;
    metadata: Array<IdentityMetadataItemEntity>;
    createdAt: Date;
    lastUpdatedAt: Date;
    party: PartyEntity;
    partyId?: string;
    updateUpdatedDate(): void;
    validate(): Promise<void>;
}

declare class ConnectionEntity extends BaseEntity {
    id: string;
    type: ConnectionType;
    tenantId?: string;
    ownerId?: string;
    config: BaseConfigEntity;
    identity: IdentityEntity;
}

declare abstract class BaseConfigEntity extends BaseEntity {
    id: string;
    connection?: ConnectionEntity;
}

declare class DidAuthConfigEntity extends BaseConfigEntity {
    identifier: string;
    redirectUrl: string;
    sessionId: string;
    ownerId?: string;
    tenantId?: string;
}

declare class OpenIdConfigEntity extends BaseConfigEntity {
    clientId: string;
    clientSecret?: string;
    scopes: Array<string>;
    issuer: string;
    redirectUrl: string;
    dangerouslyAllowInsecureHttpRequests: boolean;
    clientAuthMethod: 'basic' | 'post' | undefined;
    ownerId?: string;
    tenantId?: string;
}

declare class DigitalCredentialEntity extends BaseEntity implements DigitalCredential {
    id: string;
    parentId?: string;
    documentType: DocumentType;
    regulationType: RegulationType;
    documentFormat: CredentialDocumentFormat;
    credentialRole: CredentialRole;
    rawDocument: string;
    uniformDocument: string;
    credentialId: string;
    hash: string;
    kmsKeyRef: string;
    identifierMethod: string;
    issuerCorrelationType: CredentialCorrelationType;
    subjectCorrelationType?: CredentialCorrelationType;
    rpCorrelationType?: CredentialCorrelationType;
    isIssuerSigned?: boolean;
    issuerCorrelationId: string;
    subjectCorrelationId?: string;
    rpCorrelationId?: string;
    verifiedState?: CredentialStateType;
    tenantId?: string;
    linkedVpId?: string;
    linkedVpFrom?: Date;
    linkedVpUntil?: Date;
    createdAt: Date;
    presentedAt?: Date;
    lastUpdatedAt: Date;
    validUntil?: Date;
    validFrom?: Date;
    verifiedAt?: Date;
    revokedAt?: Date;
}

declare class AuditEventEntity extends BaseEntity {
    id: string;
    timestamp: Date;
    type: LoggingEventType;
    level: LogLevel;
    correlationId: string;
    system: System;
    subSystemType: SubSystem;
    actionType: ActionType;
    actionSubType: ActionSubType;
    initiatorType: InitiatorType;
    systemCorrelationIdType?: SystemCorrelationIdType;
    systemCorrelationId?: string;
    systemAlias?: string;
    partyCorrelationType?: PartyCorrelationType;
    partyCorrelationId?: string;
    partyAlias?: string;
    description: string;
    credentialType?: CredentialType;
    credentialHash?: string;
    parentCredentialHash?: string;
    originalCredential?: string;
    sharePurpose?: string;
    data?: string;
    diagnosticData?: string;
    createdAt: Date;
    lastUpdatedAt: Date;
}

declare class ImageDimensionsEntity extends BaseEntity {
    id: string;
    width: number;
    height: number;
}

declare class ImageAttributesEntity extends BaseEntity {
    id: string;
    uri?: string;
    dataUri?: string;
    mediaType?: string;
    alt?: string;
    dimensions?: ImageDimensionsEntity;
    validate(): Promise<undefined>;
}

declare class BackgroundAttributesEntity extends BaseEntity {
    id: string;
    color?: string;
    image?: ImageAttributesEntity;
    validate(): Promise<undefined>;
}

declare class TextAttributesEntity extends BaseEntity {
    id: string;
    color?: string;
    validate(): Promise<undefined>;
}

declare class BaseLocaleBrandingEntity extends BaseEntity {
    id: string;
    alias?: string;
    locale?: string;
    logo?: ImageAttributesEntity;
    description?: string;
    background?: BackgroundAttributesEntity;
    text?: TextAttributesEntity;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    validate(): Promise<undefined>;
}

declare class CredentialClaimsEntity extends BaseEntity {
    id: string;
    key: string;
    name: string;
    order?: number;
    credentialLocaleBranding: CredentialLocaleBrandingEntity;
    validate(): Promise<undefined>;
}

declare class CredentialLocaleBrandingEntity extends BaseLocaleBrandingEntity {
    credentialBranding: CredentialBrandingEntity;
    claims: Array<CredentialClaimsEntity>;
    credentialBrandingId: string;
    state: string;
    setState(): void;
}

declare class CredentialBrandingEntity extends BaseEntity {
    id: string;
    vcHash: string;
    issuerCorrelationId: string;
    state: string;
    localeBranding: Array<CredentialLocaleBrandingEntity>;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    setState(): void;
    validate(): Promise<undefined>;
    private computeState;
}

declare class IssuerLocaleBrandingEntity extends BaseLocaleBrandingEntity {
    issuerBranding: IssuerBrandingEntity;
    clientUri?: string;
    tosUri?: string;
    policyUri?: string;
    contacts?: Array<string>;
    issuerBrandingId: string;
    state: string;
    setState(): void;
    private computeState;
}

declare class IssuerBrandingEntity extends BaseEntity {
    id: string;
    issuerCorrelationId: string;
    localeBranding: Array<IssuerLocaleBrandingEntity>;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
    validate(): Promise<undefined>;
}

/**
 * @class MachineStateInfoEntity
 * Represents a machine state. It allows to continue a machine at a later point in time at the point it was left of
 *
 * @param {string} instanceId - The instance ID of the machine state.
 * @param {string} [sessionId] - The session ID of the machine state. (optional)
 * @param {string} machineName - The name of the machine.
 * @param {string} [latestStateName] - The name of the latest state. (optional)
 * @param {string} latestEventType - The type of the latest event.
 * @param {string} state - The current state of the machine.
 * @param {Date} createdAt - The date and time when the machine state was created.
 * @param {Date} updatedAt - The date and time when the machine state was last updated.
 * @param {number} updatedCount - The number of times the machine state has been updated.
 * @param {Date} [expiresAt] - The date and time when the machine state expires. (optional)
 * @param {Date} [completedAt] - The date and time when the machine state was completed. (optional)
 * @param {string} [tenantId] - The ID of the tenant associated with the machine state. (optional)
 */
declare class MachineStateInfoEntity extends BaseEntity {
    instanceId: string;
    sessionId?: string;
    machineName: string;
    latestStateName?: string;
    latestEventType: string;
    state: string;
    createdAt: Date;
    updatedAt: Date;
    updatedCount: number;
    expiresAt?: Date;
    completedAt?: Date;
    tenantId?: string;
}

declare class Oid4vcStateEntity<StateType> extends BaseEntity {
    id: string;
    lookups?: Array<string>;
    stateId?: string;
    correlationId?: string;
    state: StateType;
    createdAt: Date;
    updatedAt: Date;
    expiresAt?: Date;
    tenantId?: string;
}

declare class DcqlQueryItemEntity extends BaseEntity {
    id: string;
    queryId: string;
    version: string;
    tenantId?: string;
    purpose?: string;
    name?: string;
    query: string;
    createdAt: Date;
    lastUpdatedAt: Date;
    updateUpdatedDate(): void;
}

declare class StatusListEntryEntity extends BaseEntity {
    statusListId: string;
    statusListIndex: number;
    statusList: StatusListEntity;
    credentialId?: string;
    credentialHash?: string;
    entryCorrelationId?: string;
    value?: string;
}

declare abstract class StatusListEntity extends BaseEntity {
    id: string;
    correlationId: string;
    length: number;
    type: StatusListType;
    issuer: string | IIssuer;
    driverType: StatusListDriverType;
    credentialIdMode: StatusListCredentialIdMode;
    proofFormat: CredentialProofFormat;
    statusListCredential?: StatusListCredential;
}
declare class StatusList2021Entity extends StatusListEntity {
    indexingDirection: StatusListIndexingDirection;
    statusPurpose: StatusPurpose2021;
    statusListEntries: StatusListEntryEntity[];
}
declare class OAuthStatusListEntity extends StatusListEntity {
    bitsPerStatus: number;
    expiresAt?: Date;
}
declare class BitstringStatusListEntity extends StatusListEntity {
    statusPurpose: string | string[];
    bitsPerStatus?: number;
    validFrom?: Date;
    validUntil?: Date;
    ttl?: number;
    statusListEntries: BitstringStatusListEntryEntity[];
}

interface IStatusListEntity {
    id: string;
    correlationId: string;
    driverType: StatusListDriverType;
    credentialIdMode: StatusListCredentialIdMode;
    length: number;
    issuer: string | IIssuer;
    type: StatusListType;
    proofFormat: CredentialProofFormat;
    statusListCredential?: StatusListCredential;
    bitsPerStatus?: number;
}
interface IStatusList2021Entity extends IStatusListEntity {
    indexingDirection: StatusListIndexingDirection;
    statusPurpose: StatusPurpose2021;
}
interface IOAuthStatusListEntity extends IStatusListEntity {
    bitsPerStatus: number;
    expiresAt?: Date;
}
interface IBitstringStatusListEntity extends IStatusListEntity {
    statusPurpose: BitstringStatusPurpose | Array<BitstringStatusPurpose>;
    bitsPerStatus?: number;
    validFrom?: Date;
    validUntil?: Date;
    ttl?: number;
}
type IStatusListEntryEntity = RequireOneOf<{
    statusList: StatusListEntity;
    statusListId: string;
    value?: string;
    statusListIndex: number;
    credentialHash?: string;
    credentialId?: string;
    correlationId?: string;
}, 'statusList' | 'statusListId'>;
type BitstringStatusPurpose = 'revocation' | 'suspension' | 'refresh' | 'message' | string;
type BitstringStatusMessage = {
    status: string;
    message?: string;
    [x: string]: any;
};
interface BitstringStatusListEntryCredentialStatus extends ICredentialStatus {
    type: 'BitstringStatusListEntry';
    statusPurpose: BitstringStatusPurpose | Array<BitstringStatusPurpose>;
    statusListIndex: string;
    statusListCredential: string;
    bitsPerStatus?: number;
    statusMessage?: Array<BitstringStatusMessage>;
    statusReference?: string | Array<string>;
}
type BitstringStatusListArgs = {
    statusPurpose: BitstringStatusPurpose;
    bitsPerStatus: number;
    ttl?: number;
    validFrom?: Date;
    validUntil?: Date;
};
interface IBitstringStatusListEntryEntity {
    statusListId: string;
    statusListIndex: number;
    credentialId?: string;
    credentialHash?: string;
    entryCorrelationId?: string;
    statusPurpose: string;
    bitsPerStatus?: number;
    statusMessage?: Array<BitstringStatusMessage>;
    statusReference?: string | Array<string>;
}

type FindStatusListArgs = FindOptionsWhere<IStatusList2021Entity | IOAuthStatusListEntity>[];
type FindStatusListEntryArgs = FindOptionsWhere<IStatusListEntryEntity>[] | FindOptionsWhere<IStatusListEntryEntity>;
interface IStatusListEntryAvailableArgs {
    statusListId?: string;
    correlationId?: string;
    statusListIndex: number | number[];
}
interface IGetStatusListEntryByIndexArgs {
    statusListId?: string;
    statusListCorrelationId?: string;
    statusListIndex?: number;
    entryCorrelationId?: string;
    errorOnNotFound?: boolean;
}
interface IGetStatusListEntryByCredentialIdArgs {
    statusListId?: string;
    statusListCorrelationId?: string;
    entryCorrelationId?: string;
    credentialId: string;
    errorOnNotFound?: boolean;
}
interface IGetStatusListEntriesArgs {
    statusListId: string;
    filter?: FindStatusListEntryArgs;
}
type IAddStatusListEntryArgs = IStatusListEntryEntity | IBitstringStatusListEntryEntity;
interface IGetStatusListArgs {
    id?: string;
    correlationId?: string;
}
type IRemoveStatusListArgs = IGetStatusListArgs;
interface IGetStatusListsArgs {
    filter?: FindStatusListArgs;
}
interface IBaseStatusListArgs {
    id: string;
    correlationId: string;
    driverType: StatusListDriverType;
    credentialIdMode: StatusListCredentialIdMode;
    length: number;
    issuer: string | IIssuer;
    type: StatusListType;
    proofFormat: CredentialProofFormat;
    statusListCredential?: StatusListCredential;
    bitsPerStatus?: number;
}
type IStatusList2021Args = IBaseStatusListArgs & {
    type: StatusListType.StatusList2021;
    indexingDirection: StatusListIndexingDirection;
    statusPurpose: StatusPurpose2021;
};
type IOAuthStatusListArgs = IBaseStatusListArgs & {
    type: StatusListType.OAuthStatusList;
    bitsPerStatus: number;
    expiresAt?: Date;
};
type IBitstringStatusListArgs = IBaseStatusListArgs & {
    type: StatusListType.BitstringStatusList;
    statusPurpose: BitstringStatusPurpose | BitstringStatusPurpose[];
    bitsPerStatus?: number;
    validFrom?: Date;
    validUntil?: Date;
    ttl?: number;
};
type IAddStatusListArgs = IStatusList2021Args | IOAuthStatusListArgs | IBitstringStatusListArgs;
type IUpdateStatusListIndexArgs = IAddStatusListArgs;

declare class BitstringStatusListEntryEntity extends StatusListEntryEntity {
    statusPurpose: string;
    bitsPerStatus?: number;
    statusMessage?: Array<BitstringStatusMessage>;
    statusReference?: string | string[];
}

declare class ContactStore extends AbstractContactStore {
    private readonly dbConnection;
    constructor(dbConnection: OrPromise<DataSource>);
    getParty: (args: GetPartyArgs) => Promise<Party>;
    getParties: (args?: GetPartiesArgs) => Promise<Array<Party>>;
    addParty: (args: AddPartyArgs) => Promise<Party>;
    updateParty: (args: UpdatePartyArgs) => Promise<Party>;
    removeParty: (args: RemovePartyArgs) => Promise<void>;
    getIdentity: (args: GetIdentityArgs) => Promise<Identity>;
    getIdentities: (args?: GetIdentitiesArgs) => Promise<Array<Identity>>;
    addIdentity: (args: AddIdentityArgs) => Promise<Identity>;
    updateIdentity: (args: UpdateIdentityArgs) => Promise<Identity>;
    removeIdentity: (args: RemoveIdentityArgs) => Promise<void>;
    addRelationship: (args: AddRelationshipArgs) => Promise<PartyRelationship>;
    getRelationship: (args: GetRelationshipArgs) => Promise<PartyRelationship>;
    getRelationships: (args?: GetRelationshipsArgs) => Promise<Array<PartyRelationship>>;
    updateRelationship: (args: UpdateRelationshipArgs) => Promise<PartyRelationship>;
    removeRelationship: (args: RemoveRelationshipArgs) => Promise<void>;
    addPartyType: (args: AddPartyTypeArgs) => Promise<PartyType>;
    getPartyType: (args: GetPartyTypeArgs) => Promise<PartyType>;
    getPartyTypes: (args?: GetPartyTypesArgs) => Promise<Array<PartyType>>;
    updatePartyType: (args: UpdatePartyTypeArgs) => Promise<PartyType>;
    removePartyType: (args: RemovePartyTypeArgs) => Promise<void>;
    getElectronicAddress: (args: GetElectronicAddressArgs) => Promise<ElectronicAddress>;
    getElectronicAddresses: (args?: GetElectronicAddressesArgs) => Promise<Array<ElectronicAddress>>;
    addElectronicAddress: (args: AddElectronicAddressArgs) => Promise<ElectronicAddress>;
    updateElectronicAddress: (args: UpdateElectronicAddressArgs) => Promise<ElectronicAddress>;
    removeElectronicAddress: (args: RemoveElectronicAddressArgs) => Promise<void>;
    getPhysicalAddress: (args: GetPhysicalAddressArgs) => Promise<PhysicalAddress>;
    getPhysicalAddresses: (args?: GetPhysicalAddressesArgs) => Promise<Array<PhysicalAddress>>;
    addPhysicalAddress: (args: AddPhysicalAddressArgs) => Promise<PhysicalAddress>;
    updatePhysicalAddress: (args: UpdatePhysicalAddressArgs) => Promise<PhysicalAddress>;
    removePhysicalAddress: (args: RemovePhysicalAddressArgs) => Promise<void>;
    private hasCorrectConnectionConfig;
    private hasCorrectPartyType;
    private deleteIdentities;
    private deleteElectronicAddresses;
    private deletePhysicalAddresses;
    private assertRelationshipSides;
    private buildFilters;
    private processCondition;
    private buildMetadataCondition;
}

declare class DigitalCredentialStore extends AbstractDigitalCredentialStore {
    private readonly dbConnection;
    private dcRepo;
    constructor(dbConnection: OrPromise<DataSource>);
    addCredential: (args: AddCredentialArgs) => Promise<DigitalCredential>;
    getCredential: (args: GetCredentialArgs) => Promise<DigitalCredential>;
    getCredentials: (args?: GetCredentialsArgs) => Promise<GetCredentialsResponse>;
    updateCredential: (args: UpdateCredentialArgs) => Promise<DigitalCredential>;
    removeCredential: (args: RemoveCredentialArgs) => Promise<boolean>;
    private deleteTree;
    private getRepository;
    updateCredentialState: (args: UpdateCredentialStateArgs) => Promise<DigitalCredential>;
    private assertValidDigitalCredential;
}

declare class IssuanceBrandingStore extends AbstractIssuanceBrandingStore {
    private readonly dbConnection;
    constructor(dbConnection: OrPromise<DataSource>);
    addCredentialBranding: (args: IAddCredentialBrandingArgs) => Promise<ICredentialBranding>;
    getCredentialBranding: (args?: IGetCredentialBrandingArgs) => Promise<Array<ICredentialBranding>>;
    removeCredentialBranding: (args: IRemoveCredentialBrandingArgs) => Promise<void>;
    updateCredentialBranding: (args: IUpdateCredentialBrandingArgs) => Promise<ICredentialBranding>;
    addCredentialLocaleBranding: (args: IAddCredentialLocaleBrandingArgs) => Promise<ICredentialBranding>;
    getCredentialLocaleBranding: (args?: IGetCredentialLocaleBrandingArgs) => Promise<Array<ICredentialLocaleBranding>>;
    removeCredentialLocaleBranding: (args: IRemoveCredentialLocaleBrandingArgs) => Promise<void>;
    updateCredentialLocaleBranding: (args: IUpdateCredentialLocaleBrandingArgs) => Promise<ICredentialLocaleBranding>;
    addIssuerBranding: (args: IAddIssuerBrandingArgs) => Promise<IIssuerBranding>;
    getIssuerBranding: (args?: IGetIssuerBrandingArgs) => Promise<Array<IIssuerBranding>>;
    removeIssuerBranding: (args: IRemoveIssuerBrandingArgs) => Promise<void>;
    updateIssuerBranding: (args: IUpdateIssuerBrandingArgs) => Promise<IIssuerBranding>;
    addIssuerLocaleBranding: (args: IAddIssuerLocaleBrandingArgs) => Promise<IIssuerBranding>;
    getIssuerLocaleBranding: (args?: IGetIssuerLocaleBrandingArgs) => Promise<Array<IIssuerLocaleBranding>>;
    removeIssuerLocaleBranding: (args: IRemoveIssuerLocaleBrandingArgs) => Promise<void>;
    updateIssuerLocaleBranding: (args: IUpdateIssuerLocaleBrandingArgs) => Promise<IIssuerLocaleBranding>;
    private hasDuplicateLocales;
    private removeLocaleBranding;
}

interface IStatusListStore {
    getStatusList(args: IGetStatusListArgs): Promise<IStatusListEntity | IBitstringStatusListEntity>;
    getStatusLists(args: IGetStatusListsArgs): Promise<Array<IStatusListEntity | IBitstringStatusListEntity>>;
    removeStatusList(args: IRemoveStatusListArgs): Promise<boolean>;
    addStatusList(args: IAddStatusListArgs): Promise<IStatusListEntity | IBitstringStatusListEntity>;
    updateStatusList(args: IUpdateStatusListIndexArgs): Promise<IStatusListEntity | IBitstringStatusListEntity>;
    availableStatusListEntries(args: IStatusListEntryAvailableArgs): Promise<number[]>;
    addStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity | IBitstringStatusListEntryEntity>;
    updateStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity | IBitstringStatusListEntryEntity>;
    getStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<StatusListEntryEntity | BitstringStatusListEntryEntity | undefined>;
    getStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<StatusListEntryEntity | BitstringStatusListEntryEntity | undefined>;
    removeStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<boolean>;
    removeStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<boolean>;
    getStatusListEntries(args: IGetStatusListEntriesArgs): Promise<Array<IStatusListEntryEntity | IBitstringStatusListEntryEntity>>;
}

declare class StatusListStore implements IStatusListStore {
    private readonly _dbConnection;
    constructor(dbConnection: OrPromise<DataSource>);
    /**
     * Gets the available status list indices from the provided indices. Meaning it will filter out any index that is already known.
     *
     * The idea is that the caller provides a set of random status list indices. We can relatively easy check against the DB in an optimized way.
     * If the status list is large it is probably best to also provide at least a good number of indices. So something like 10 or 20 values.
     * Callers are also expected to call this function multiple times if it does not yield results
     *
     * @param args
     */
    availableStatusListEntries(args: IStatusListEntryAvailableArgs): Promise<number[]>;
    addStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity | IBitstringStatusListEntryEntity>;
    updateStatusListEntry(args: IAddStatusListEntryArgs): Promise<IStatusListEntryEntity | IBitstringStatusListEntryEntity>;
    getStatusListEntryByIndex({ statusListId, statusListCorrelationId, statusListIndex, entryCorrelationId, errorOnNotFound, }: IGetStatusListEntryByIndexArgs): Promise<StatusListEntryEntity | BitstringStatusListEntryEntity | undefined>;
    getStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<StatusListEntryEntity | BitstringStatusListEntryEntity | undefined>;
    removeStatusListEntryByCredentialId(args: IGetStatusListEntryByCredentialIdArgs): Promise<boolean>;
    removeStatusListEntryByIndex(args: IGetStatusListEntryByIndexArgs): Promise<boolean>;
    getStatusListEntries(args: IGetStatusListEntriesArgs): Promise<Array<IStatusListEntryEntity | IBitstringStatusListEntryEntity>>;
    private getStatusListEntity;
    getStatusList(args: IGetStatusListArgs): Promise<IStatusListEntity | IBitstringStatusListEntity>;
    getStatusLists(args: IGetStatusListsArgs): Promise<Array<IStatusListEntity | IBitstringStatusListEntity>>;
    addStatusList(args: IAddStatusListArgs): Promise<IStatusListEntity>;
    updateStatusList(args: IUpdateStatusListIndexArgs): Promise<IStatusListEntity | IBitstringStatusListEntity>;
    removeStatusList(args: IRemoveStatusListArgs): Promise<boolean>;
    private getDS;
    getStatusListRepo(type?: StatusListType): Promise<Repository<StatusListEntity>>;
    getStatusListEntryRepo(type?: StatusListType): Promise<Repository<StatusListEntryEntity | BitstringStatusListEntryEntity>>;
}

declare class EventLoggerStore extends AbstractEventLoggerStore {
    private readonly dbConnection;
    constructor(dbConnection: OrPromise<DataSource>);
    getAuditEvents: (args?: GetAuditEventsArgs) => Promise<Array<AuditLoggingEvent>>;
    storeAuditEvent: (args: StoreAuditEventArgs) => Promise<AuditLoggingEvent>;
    getActivityEvents: (args?: GetActivityEventsArgs) => Promise<Array<ActivityLoggingEvent>>;
    storeActivityEvent: (args: StoreActivityEventArgs) => Promise<ActivityLoggingEvent>;
}

/**
 * Represents a data store for managing machine states.
 */
declare class MachineStateStore extends IAbstractMachineStateStore {
    private readonly _dbConnection;
    constructor(dbConnection: OrPromise<DataSource>);
    persistMachineState(state: StoreMachineStatePersistArgs): Promise<StoreMachineStateInfo>;
    findActiveMachineStates(args: StoreMachineStatesFindActiveArgs): Promise<Array<StoreMachineStateInfo>>;
    findMachineStates(args?: StoreFindMachineStatesArgs): Promise<Array<StoreMachineStateInfo>>;
    getMachineState(args: StoreMachineStateGetArgs): Promise<StoreMachineStateInfo>;
    deleteMachineState(args: StoreMachineStateDeleteArgs): Promise<boolean>;
    deleteExpiredMachineStates(args: StoreMachineStateDeleteExpiredArgs): Promise<number>;
    protected static machineInfoFrom: (machineStateInfoEntity: MachineStateInfoEntity) => StoreMachineStateInfo;
    static machineStateInfoEntityFrom: (machineStateInfo: StoreMachineStateInfo | StoreMachineStatePersistArgs) => MachineStateInfoEntity;
}

declare class PDStore extends AbstractPDStore {
    private readonly dbConnection;
    constructor(dbConnection: OrPromise<DataSource>);
    getDefinition: (args: GetDefinitionArgs) => Promise<DcqlQueryItem>;
    hasDefinition: (args: HasDefinitionArgs) => Promise<boolean>;
    hasDefinitions: (args: HasDefinitionsArgs) => Promise<boolean>;
    getDefinitions: (args: GetDefinitionsArgs) => Promise<Array<DcqlQueryItem>>;
    addDefinition: (item: NonPersistedDcqlQueryItem) => Promise<DcqlQueryItem>;
    updateDefinition: (item: DcqlQueryItem) => Promise<DcqlQueryItem>;
    deleteDefinition: (args: DeleteDefinitionArgs) => Promise<void>;
    deleteDefinitions: (args: DeleteDefinitionsArgs) => Promise<number>;
    findIds: (pdRepository: Repository<DcqlQueryItemEntity>, filter: Array<DcqlQueryItemFilter> | undefined) => Promise<Array<DcqlQueryItemEntity>>;
}

declare class CreateContacts1659463079429 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class CreatePresentationDefinitions1716533767523 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class FixCredentialClaimsReferencesUuid1741895822987 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class AddBitstringStatusListEnum1741895823000 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class AddLinkedVpFields1763387280000 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class AddServiceMetadata1764000000000 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class CreateAuditEvents1701635835330 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

declare class CreateMachineStateStore1708098041262 implements MigrationInterface {
    name: string;
    up(queryRunner: QueryRunner): Promise<void>;
    down(queryRunner: QueryRunner): Promise<void>;
}

/**
 * The migrations array that SHOULD be used when initializing a TypeORM database connection.
 *
 * These ensure the correct creation of tables and the proper migrations of data when tables change between versions.
 *
 * @public
 */
declare const DataStoreContactMigrations: (typeof CreateContacts1659463079429)[];
declare const DataStoreIssuanceBrandingMigrations: (typeof FixCredentialClaimsReferencesUuid1741895822987)[];
declare const DataStoreStatusListMigrations: (typeof AddBitstringStatusListEnum1741895823000)[];
declare const DataStoreEventLoggerMigrations: (typeof CreateAuditEvents1701635835330)[];
declare const DataStoreDigitalCredentialMigrations: (typeof AddLinkedVpFields1763387280000)[];
declare const DataStoreMachineStateMigrations: (typeof CreateMachineStateStore1708098041262)[];
declare const DataStorePresentationDefinitionMigrations: (typeof CreatePresentationDefinitions1716533767523)[];
declare const DataStoreServiceMigrations: (typeof AddServiceMetadata1764000000000)[];
declare const DataStoreMigrations: (typeof CreateContacts1659463079429)[];
declare const DataStoreMigrationsWithVeramo: (typeof CreateContacts1659463079429)[];

declare class NaturalPersonEntity extends BaseContactEntity {
    firstName: string;
    middleName?: string;
    lastName: string;
    displayName: string;
    ownerId?: string;
    tenantId?: string;
    validate(): Promise<void>;
}

declare class OrganizationEntity extends BaseContactEntity {
    legalName: string;
    displayName: string;
    ownerId?: string;
    tenantId?: string;
    validate(): Promise<void>;
}

declare const partyEntityFrom: (party: NonPersistedParty) => PartyEntity;
declare const partyFrom: (party: PartyEntity) => Party;
declare const contactEntityFrom: (contact: NonPersistedContact) => BaseContactEntity;
declare const contactFrom: (contact: BaseContactEntity) => Contact;
declare const isNaturalPerson: (contact: NonPersistedContact | BaseContactEntity) => contact is NonPersistedNaturalPerson | NaturalPersonEntity;
declare const isOrganization: (contact: NonPersistedContact | BaseContactEntity) => contact is NonPersistedOrganization | OrganizationEntity;
declare const connectionEntityFrom: (connection: NonPersistedConnection) => ConnectionEntity;
declare const connectionFrom: (connection: ConnectionEntity) => Connection;
declare const correlationIdentifierEntityFrom: (identifier: NonPersistedCorrelationIdentifier) => CorrelationIdentifierEntity;
declare const correlationIdentifierFrom: (identifier: CorrelationIdentifierEntity) => CorrelationIdentifier;
declare const didAuthConfigEntityFrom: (config: NonPersistedDidAuthConfig) => DidAuthConfigEntity;
declare const electronicAddressEntityFrom: (electronicAddress: NonPersistedElectronicAddress) => ElectronicAddressEntity;
declare const electronicAddressFrom: (electronicAddress: ElectronicAddressEntity) => ElectronicAddress;
declare const physicalAddressEntityFrom: (physicalAddress: NonPersistedPhysicalAddress) => PhysicalAddressEntity;
declare const physicalAddressFrom: (physicalAddress: PhysicalAddressEntity) => PhysicalAddress;
declare const identityEntityFrom: (entity: NonPersistedIdentity) => IdentityEntity;
declare const identityFrom: (identity: IdentityEntity) => Identity;
declare const identityMetadataItemEntityFrom: (item: NonPersistedMetadataItem<MetadataTypes>) => IdentityMetadataItemEntity | undefined;
declare const contactMetadataItemEntityFrom: (item: NonPersistedMetadataItem<MetadataTypes>) => ContactMetadataItemEntity | undefined;
declare const metadataItemFrom: (entity: IdentityMetadataItemEntity | ContactMetadataItemEntity) => MetadataItem<MetadataTypes>;
declare const naturalPersonEntityFrom: (naturalPerson: NonPersistedNaturalPerson) => NaturalPersonEntity;
declare const naturalPersonFrom: (naturalPerson: NaturalPersonEntity) => NaturalPerson;
declare const openIdConfigEntityFrom: (config: NonPersistedOpenIdConfig) => OpenIdConfigEntity;
declare const organizationEntityFrom: (organization: NonPersistedOrganization) => OrganizationEntity;
declare const organizationFrom: (organization: OrganizationEntity) => Organization;
declare const partyRelationshipEntityFrom: (relationship: NonPersistedPartyRelationship) => PartyRelationshipEntity;
declare const partyRelationshipFrom: (relationship: PartyRelationshipEntity) => PartyRelationship;
declare const partyTypeEntityFrom: (args: NonPersistedPartyType) => PartyTypeEntity;
declare const partyTypeFrom: (partyType: PartyTypeEntity) => PartyType;
declare const configFrom: (config: BaseConfigEntity) => ConnectionConfig;
declare const openIdConfigFrom: (config: OpenIdConfigEntity) => OpenIdConfig;
declare const didAuthConfigFrom: (config: DidAuthConfigEntity) => DidAuthConfig;
declare const isOpenIdConfig: (config: NonPersistedConnectionConfig | BaseConfigEntity) => config is OpenIdConfig | OpenIdConfigEntity;
declare const isDidAuthConfig: (config: NonPersistedConnectionConfig | BaseConfigEntity) => config is DidAuthConfig | DidAuthConfigEntity;

declare function isHex(input: string): boolean;
declare function parseRawDocument(raw: string): OriginalVerifiableCredential | OriginalVerifiablePresentation;
/**
 * Normalizes nullable fields by converting undefined to null.
 * This ensures TypeORM actually clears the database fields instead of ignoring them.
 */
declare function normalizeNullableFields<T extends Record<string, any>>(obj: T, nullableKeys: Array<keyof T>): T;
declare const nonPersistedDigitalCredentialEntityFromAddArgs: (addCredentialArgs: AddCredentialArgs) => NonPersistedDigitalCredential;
declare const persistedDigitalCredentialEntityFromUpdateArgs: (existingCredential: DigitalCredentialEntity, updates: Partial<DigitalCredential>) => DigitalCredentialEntity;
declare const persistedDigitalCredentialEntityFromStateArgs: (existingCredential: DigitalCredentialEntity, args: UpdateCredentialStateArgs) => DigitalCredentialEntity;
declare const digitalCredentialFrom: (credentialEntity: DigitalCredentialEntity) => DigitalCredential;
declare const digitalCredentialsFrom: (credentialEntities: Array<DigitalCredentialEntity>) => DigitalCredential[];

declare const auditEventFrom: (event: AuditEventEntity) => AuditLoggingEvent;
declare const auditEventEntityFrom: (args: NonPersistedAuditLoggingEvent) => AuditEventEntity;
declare const activityEventFrom: (event: AuditEventEntity) => ActivityLoggingEvent;
declare const activityEventEntityFrom: (args: NonPersistedActivityLoggingEvent) => AuditEventEntity;

declare const credentialBrandingFrom: (credentialBranding: CredentialBrandingEntity) => ICredentialBranding;
declare const issuerBrandingFrom: (issuerBranding: IssuerBrandingEntity) => IIssuerBranding;
declare const localeBrandingFrom: (localeBranding: BaseLocaleBrandingEntity) => ILocaleBranding;
declare const credentialLocaleBrandingFromEntity: (localeBranding: CredentialLocaleBrandingEntity) => ICredentialLocaleBranding;
declare const issuerLocaleBrandingEntityFrom: (args: IBasicIssuerLocaleBranding) => IssuerLocaleBrandingEntity;
declare const backgroundAttributesEntityFrom: (args: IBasicBackgroundAttributes) => BackgroundAttributesEntity;
declare const credentialBrandingEntityFrom: (args: IBasicCredentialBranding) => CredentialBrandingEntity;
declare const credentialLocaleBrandingEntityFrom: (args: IBasicCredentialLocaleBranding) => CredentialLocaleBrandingEntity;
declare const imageAttributesEntityFrom: (args: IBasicImageAttributes) => ImageAttributesEntity;
declare const imageDimensionsEntityFrom: (args: IBasicImageDimensions) => ImageDimensionsEntity;
declare const issuerBrandingEntityFrom: (args: IBasicIssuerBranding) => IssuerBrandingEntity;
declare const textAttributesEntityFrom: (args: IBasicTextAttributes) => TextAttributesEntity;
declare const credentialClaimsEntityFrom: (args: IBasicCredentialClaim) => CredentialClaimsEntity;

declare const dcqlQueryItemFrom: (entity: DcqlQueryItemEntity) => DcqlQueryItem;
declare const dcqlQueryEntityItemFrom: (item: NonPersistedDcqlQueryItem) => DcqlQueryItemEntity;
declare function isPresentationDefinitionEqual(base: PartialDcqlQueryItem, compare: PartialDcqlQueryItem): boolean;

declare const DataStoreContactEntities: (typeof BaseConfigEntity | typeof ConnectionEntity | typeof PartyEntity | typeof IdentityMetadataItemEntity | typeof CorrelationIdentifierEntity | typeof PartyRelationshipEntity | typeof PartyTypeEntity | typeof BaseContactEntity | typeof ElectronicAddressEntity | typeof PhysicalAddressEntity | typeof ContactMetadataItemEntity)[];
declare const DataStoreOid4vcStateEntities: (typeof Oid4vcStateEntity)[];
declare const DataStoreIssuanceBrandingEntities: (typeof CredentialBrandingEntity | typeof ImageAttributesEntity | typeof ImageDimensionsEntity | typeof BaseLocaleBrandingEntity | typeof IssuerBrandingEntity | typeof TextAttributesEntity | typeof CredentialClaimsEntity)[];
declare const DataStorePresentationDefinitionEntities: (typeof DcqlQueryItemEntity)[];
declare const DataStoreStatusListEntities: (typeof StatusListEntity | typeof StatusListEntryEntity)[];
declare const DataStoreEventLoggerEntities: (typeof AuditEventEntity)[];
declare const DataStoreDigitalCredentialEntities: (typeof DigitalCredentialEntity)[];
declare const DataStoreMachineStateEntities: (typeof MachineStateInfoEntity)[];
declare const DataStoreEntities: (typeof BaseConfigEntity | typeof ConnectionEntity | typeof PartyEntity | typeof IdentityMetadataItemEntity | typeof CorrelationIdentifierEntity | typeof PartyRelationshipEntity | typeof PartyTypeEntity | typeof BaseContactEntity | typeof ElectronicAddressEntity | typeof PhysicalAddressEntity | typeof ContactMetadataItemEntity | typeof CredentialBrandingEntity | typeof ImageAttributesEntity | typeof ImageDimensionsEntity | typeof BaseLocaleBrandingEntity | typeof IssuerBrandingEntity | typeof TextAttributesEntity | typeof CredentialClaimsEntity | typeof DcqlQueryItemEntity | typeof StatusListEntity | typeof StatusListEntryEntity | typeof AuditEventEntity | typeof DigitalCredentialEntity | typeof MachineStateInfoEntity)[];
declare const DataStoreEntitiesWithVeramo: (typeof BaseConfigEntity | typeof ConnectionEntity | typeof PartyEntity | typeof IdentityMetadataItemEntity | typeof CorrelationIdentifierEntity | typeof PartyRelationshipEntity | typeof PartyTypeEntity | typeof BaseContactEntity | typeof ElectronicAddressEntity | typeof PhysicalAddressEntity | typeof ContactMetadataItemEntity | typeof CredentialBrandingEntity | typeof ImageAttributesEntity | typeof ImageDimensionsEntity | typeof BaseLocaleBrandingEntity | typeof IssuerBrandingEntity | typeof TextAttributesEntity | typeof CredentialClaimsEntity | typeof DcqlQueryItemEntity | typeof StatusListEntity | typeof StatusListEntryEntity | typeof AuditEventEntity | typeof DigitalCredentialEntity | typeof MachineStateInfoEntity | typeof _veramo_data_store.Key | typeof _veramo_data_store.Identifier | typeof _veramo_data_store.Message | typeof _veramo_data_store.Claim | typeof _veramo_data_store.Credential | typeof _veramo_data_store.Presentation | typeof _veramo_data_store.Service | typeof _veramo_data_store.PrivateKey)[];

export { AuditEventEntity, BackgroundAttributesEntity, BaseConfigEntity, BaseContactEntity, BaseLocaleBrandingEntity, type BitstringStatusListArgs, BitstringStatusListEntity, type BitstringStatusListEntryCredentialStatus, BitstringStatusListEntryEntity, type BitstringStatusMessage, type BitstringStatusPurpose, ConnectionEntity, ContactMetadataItemEntity, ContactStore, CorrelationIdentifierEntity, CredentialBrandingEntity, CredentialClaimsEntity, CredentialLocaleBrandingEntity, DataStoreContactEntities, DataStoreContactMigrations, DataStoreDigitalCredentialEntities, DataStoreDigitalCredentialMigrations, DataStoreEntities, DataStoreEntitiesWithVeramo, DataStoreEventLoggerEntities, DataStoreEventLoggerMigrations, DataStoreIssuanceBrandingEntities, DataStoreIssuanceBrandingMigrations, DataStoreMachineStateEntities, DataStoreMachineStateMigrations, DataStoreMigrations, DataStoreMigrationsWithVeramo, DataStoreOid4vcStateEntities, DataStorePresentationDefinitionEntities, DataStorePresentationDefinitionMigrations, DataStoreServiceMigrations, DataStoreStatusListEntities, DataStoreStatusListMigrations, DcqlQueryItemEntity, DidAuthConfigEntity, DigitalCredentialEntity, DigitalCredentialStore, ElectronicAddressEntity, EventLoggerStore, type FindStatusListArgs, type FindStatusListEntryArgs, type IAddStatusListArgs, type IAddStatusListEntryArgs, type IBitstringStatusListArgs, type IBitstringStatusListEntity, type IBitstringStatusListEntryEntity, type IGetStatusListArgs, type IGetStatusListEntriesArgs, type IGetStatusListEntryByCredentialIdArgs, type IGetStatusListEntryByIndexArgs, type IGetStatusListsArgs, type IOAuthStatusListArgs, type IOAuthStatusListEntity, type IRemoveStatusListArgs, type IStatusList2021Args, type IStatusList2021Entity, type IStatusListEntity, type IStatusListEntryAvailableArgs, type IStatusListEntryEntity, type IUpdateStatusListIndexArgs, IdentityEntity, IdentityMetadataItemEntity, ImageAttributesEntity, ImageDimensionsEntity, IssuanceBrandingStore, IssuerBrandingEntity, IssuerLocaleBrandingEntity, MachineStateInfoEntity, MachineStateStore, OAuthStatusListEntity, Oid4vcStateEntity, OpenIdConfigEntity, PDStore, PartyEntity, PhysicalAddressEntity, StatusList2021Entity, StatusListEntity, StatusListEntryEntity, StatusListStore, TextAttributesEntity, activityEventEntityFrom, activityEventFrom, auditEventEntityFrom, auditEventFrom, backgroundAttributesEntityFrom, configFrom, connectionEntityFrom, connectionFrom, contactEntityFrom, contactFrom, contactMetadataItemEntityFrom, correlationIdentifierEntityFrom, correlationIdentifierFrom, credentialBrandingEntityFrom, credentialBrandingFrom, credentialClaimsEntityFrom, credentialLocaleBrandingEntityFrom, credentialLocaleBrandingFromEntity, dcqlQueryEntityItemFrom, dcqlQueryItemFrom, didAuthConfigEntityFrom, didAuthConfigFrom, digitalCredentialFrom, digitalCredentialsFrom, electronicAddressEntityFrom, electronicAddressFrom, identityEntityFrom, identityFrom, identityMetadataItemEntityFrom, imageAttributesEntityFrom, imageDimensionsEntityFrom, isDidAuthConfig, isHex, isNaturalPerson, isOpenIdConfig, isOrganization, isPresentationDefinitionEqual, issuerBrandingEntityFrom, issuerBrandingFrom, issuerLocaleBrandingEntityFrom, localeBrandingFrom, metadataItemFrom, naturalPersonEntityFrom, naturalPersonFrom, nonPersistedDigitalCredentialEntityFromAddArgs, normalizeNullableFields, openIdConfigEntityFrom, openIdConfigFrom, organizationEntityFrom, organizationFrom, parseRawDocument, partyEntityFrom, partyFrom, partyRelationshipEntityFrom, partyRelationshipFrom, partyTypeEntityFrom, partyTypeFrom, persistedDigitalCredentialEntityFromStateArgs, persistedDigitalCredentialEntityFromUpdateArgs, physicalAddressEntityFrom, physicalAddressFrom, textAttributesEntityFrom };