@punks/backend-entity-manager 0.0.196 → 0.0.198

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-/// <reference types="express-serve-static-core" />
-/// <reference types="multer" />
 /// <reference types="qs" />
 /// <reference types="express" />
+/// <reference types="express-serve-static-core" />
+/// <reference types="multer" />
 import * as _punks_backend_core from '@punks/backend-core';
 import { Repository, ObjectLiteral, FindOneOptions, FindManyOptions, FindOptionsRelations, ObjectId, FindOptionsWhere, FindOperator, FindOptionsOrder } from 'typeorm';
 import * as _nestjs_common from '@nestjs/common';
@@ -502,124 +502,19 @@ interface IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
 interface IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> extends IEntityCreateCommandAdapter<TEntity, TEntityCreateData>, IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
 }
 
-interface IAuthenticationUserRole {
-    uid: string;
-}
-interface IAuthenticationUserPermission {
-    uid: string;
-}
-interface IAuthenticationOrganizationalUnit {
-    id: string;
-    uid: string;
-}
-interface IAuthenticationContext<TUserContextData> {
-    isAuthenticated: boolean;
-    isAnonymous: boolean;
-    userId?: string;
-    userContext?: TUserContextData;
-    userRoles?: IAuthenticationUserRole[];
-    userPermissions?: IAuthenticationUserPermission[];
-    userOrganizationalUnits?: IAuthenticationOrganizationalUnit[];
-}
-interface IAuthenticationContextProvider<TUserContext> {
-    getContext(): Promise<IAuthenticationContext<TUserContext>>;
-}
-interface IAuthenticationMiddleware<TAuthenticationContext, TOutput> {
-    processContext(context: IAuthenticationContext<TAuthenticationContext>): Promise<TOutput>;
-    getPriority(): number;
-}
-
-type BucketFolderListInput = {
-    bucket: string;
-    maxResults?: number;
-    path?: string;
-};
-declare enum BucketItemType {
-    File = "file",
-    Folder = "folder"
-}
-type BucketContentItem = {
-    type: BucketItemType;
-    name: string;
-    path: string;
-};
-type BucketFolderContentResult = {
-    items: BucketContentItem[];
-};
-type BucketFolderListResult = {};
-type BucketFolderCreateInput = {
-    bucket: string;
-    path: string;
-};
-type BucketFolderEnsureInput = {
-    bucket: string;
-    path: string;
-};
-type BucketFolderExistsInput = {
-    bucket: string;
-    path: string;
-};
-type BucketFileDownloadInput = {
-    bucket: string;
-    filePath: string;
-};
-type BucketFilePublicUrlCreateInput = {
-    bucket: string;
-    filePath: string;
-    expirationMinutes: number;
-};
-type BucketFileUploadInput = {
-    bucket: string;
-    filePath: string;
-    content: Buffer;
-    contentType?: string;
-};
-interface BucketFileDeleteInput {
-    bucket: string;
-    filePath: string;
-}
-interface IBucketProvider {
-    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
-    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
-    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
-    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
-    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
-    fileUpload(input: BucketFileUploadInput): Promise<void>;
-    fileDelete(input: BucketFileDeleteInput): Promise<void>;
+declare class PermissionsChecker<TUserContext> {
+    hasAny(context: IAuthenticationContext<TUserContext>, permissions: string[]): boolean;
+    hasAll(context: IAuthenticationContext<TUserContext>, permissions: string[]): boolean;
 }
 
-type CacheTtl = {
-    value: number;
-    unit: "years" | "months" | "days" | "hours" | "minutes" | "seconds";
-};
-type CacheEntryInfo = {
-    instanceName: string;
-    key: string;
-    expiration: Date;
-    createdOn: Date;
-    updatedOn: Date;
-};
-type CacheEntryDetail = CacheEntryInfo & {
-    data: any;
-};
-interface ICacheInstance {
-    getInstanceName(): string;
-    getEntries(): Promise<CacheEntryInfo[]>;
-    getEntry(key: string): Promise<CacheEntryDetail | undefined>;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, input: {
-        value: T;
-        ttl: CacheTtl;
-    }): Promise<void>;
-    retrieve<T>(key: string, input: {
-        ttl: CacheTtl;
-        valueFactory: () => Promise<T>;
-    }): Promise<T>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-}
-interface ICache {
-    getInstance(instanceName: string): Promise<ICacheInstance>;
+declare abstract class NestEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext> implements IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> {
+    protected permissions: PermissionsChecker<TUserContext>;
+    abstract canSearch(context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canRead(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canCreate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canUpdate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canDelete(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canDeleteItems(context: TAuthenticationContext): Promise<IAuthorizationResult>;
 }
 
 interface IAuthorizationResult {
@@ -634,37 +529,6 @@ interface IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends
     canDeleteItems(context: TAuthenticationContext): Promise<IAuthorizationResult>;
 }
 
-interface IResolveServiceOptions {
-    optional?: boolean;
-}
-interface IServiceLocator {
-    register<T extends ClassType>(name: string, service: Type<T>): void;
-    registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
-    registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
-    resolve<T extends ClassType>(name: string, options?: IResolveServiceOptions): T;
-    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
-    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
-}
-
-declare class ServiceLocator implements IServiceLocator {
-    private services;
-    private multipleServices;
-    all(): {
-        [key: string]: any;
-    };
-    register<T>(name: string, service: T): void;
-    registerMultiple<T>(serviceName: string, instanceName: string, service: T): void;
-    registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
-    registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
-    resolve<T>(name: string, options?: IResolveServiceOptions): T;
-    resolveMultiple<T>(serviceName: string, options?: IResolveServiceOptions): T[];
-    resolveMultipleNamed<T>(serviceName: string, instanceName: string, options?: IResolveServiceOptions): T;
-    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
-    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
-    private buildServiceTypeName;
-    private buildServiceName;
-}
-
 interface IEntityMapper<TEntity, TMappedEntity> {
     mapEntity(entity: TEntity): Promise<TMappedEntity>;
 }
@@ -841,6 +705,37 @@ type IEntityConfiguration = {
     versioning?: EntityVersioningOptions$1;
 };
 
+interface IResolveServiceOptions {
+    optional?: boolean;
+}
+interface IServiceLocator {
+    register<T extends ClassType>(name: string, service: Type<T>): void;
+    registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
+    registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
+    resolve<T extends ClassType>(name: string, options?: IResolveServiceOptions): T;
+    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
+    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
+}
+
+declare class ServiceLocator implements IServiceLocator {
+    private services;
+    private multipleServices;
+    all(): {
+        [key: string]: any;
+    };
+    register<T>(name: string, service: T): void;
+    registerMultiple<T>(serviceName: string, instanceName: string, service: T): void;
+    registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
+    registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
+    resolve<T>(name: string, options?: IResolveServiceOptions): T;
+    resolveMultiple<T>(serviceName: string, options?: IResolveServiceOptions): T[];
+    resolveMultipleNamed<T>(serviceName: string, instanceName: string, options?: IResolveServiceOptions): T;
+    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
+    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
+    private buildServiceTypeName;
+    private buildServiceName;
+}
+
 declare class EntityServiceLocator<TEntity, TEntityId> {
     private readonly services;
     private readonly entityName;
@@ -914,8 +809,8 @@ declare class EntitiesServiceLocator {
     registerCacheInstance<TCacheInstance extends ICacheInstance>(name: string, instance: TCacheInstance): this;
     resolveBucketProviders<TBucketProvider extends IFileProvider>(): TBucketProvider[];
     registerBucketProvider<TBucketProvider extends IBucketProvider>(name: string, instance: TBucketProvider): this;
-    resolveAuthenticationMiddlewares<TAuthenticationMiddleware extends IAuthenticationMiddleware<unknown, unknown>>(): TAuthenticationMiddleware[];
-    registerAuthenticationMiddleware<TAuthenticationMiddleware extends IAuthenticationMiddleware<unknown, unknown>>(name: string, instance: TAuthenticationMiddleware): this;
+    resolveAuthenticationMiddlewares<TAuthenticationMiddleware extends IAuthenticationMiddleware<any, unknown>>(): TAuthenticationMiddleware[];
+    registerAuthenticationMiddleware<TAuthenticationMiddleware extends IAuthenticationMiddleware<any, unknown>>(name: string, instance: TAuthenticationMiddleware): this;
     resolveFileProvider<TFileProvider extends IFileProvider>(providerId: string): TFileProvider;
     registerFileProvider<TFileProvider extends IFileProvider>(name: string, instance: TFileProvider): this;
     resolveFilesReferenceRepositoryProviders<TFilesReferenceRepo extends IFilesReferenceRepository>(): TFilesReferenceRepo;
@@ -1022,1768 +917,1881 @@ declare class EntitiesServiceLocator {
     registerQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>): void;
 }
 
-interface IEntitySnapshotService<TEntityId, TEntitySnapshot> {
-    getSnapshot(id: TEntityId): Promise<TEntitySnapshot>;
+interface EntityAuthMiddlewareProps {
+    entityName: string;
 }
+declare const WpEntityAuthMiddleware: (entityName: string, props?: Omit<EntityAuthMiddlewareProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-type EntitiesMapOperationsInput<TEntitiesQueryBuilder> = {
-    queryBuilder: TEntitiesQueryBuilder;
-    settings: EntityManagerSettings;
-};
-interface IEntityManagerServiceRoot {
-    locator: ServiceLocator;
-    getEntitiesServicesLocator(): EntitiesServiceLocator;
-    getEntityServicesLocator<TEntity, TEntityId>(entityName: string): EntityServiceLocator<TEntity, TEntityId>;
-    addAuthentication<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>({ provider, }: {
-        provider: TAuthenticationContextProvider;
-    }): void;
-    registerEntity<TEntity, TEntityId, TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(entity: IEntityConfiguration, repository: TRepository): IEntityManagerServiceCollection<TEntity, TEntityId>;
+interface GlobalAuthenticationMiddlewareProps {
+    name: string;
+    weight?: number;
 }
-interface IEntityManagerServiceCollection<TEntity, TEntityId> {
-    getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
-    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, unknown, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>(input: EntitiesMapOperationsInput<TEntitiesQueryBuilder>): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addSerializer<TEntitySerializer extends IEntitySerializer<TEntity, TEntityId, unknown, unknown>>(serializer: TEntitySerializer): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addSnapshotService<TEntitySnapshotService extends IEntitySnapshotService<TEntityId, unknown>>(service: TEntitySnapshotService): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addAdapter<TEntityCreateData, TEntityUpdateData, TEntityAdapter extends IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>>(adapter: TEntityAdapter): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addAuthorization<TEntityAuthorizationMiddleware extends IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>({ middleware, }: {
-        middleware: TEntityAuthorizationMiddleware;
-    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    withReplica<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>({ name, options, repository, }: {
-        name: string;
-        options: ReplicaOptions;
-        repository: TRepository;
-    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    withSynchronization<TMappedType, TMapper extends IEntityMapper<TEntity, TMappedType>, TEntityConnector extends IEntityConnector<TEntity, TMappedType>>({ name, options, connector, mapper, }: {
-        name: string;
-        options: ConnectorOptions;
-        connector: TEntityConnector;
-        mapper: TMapper;
-    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+declare const WpGlobalAuthenticationMiddleware: (name: string, props?: Omit<GlobalAuthenticationMiddlewareProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface BucketProviderProps {
+    providerId: string;
 }
+declare const WpBucketProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload> {
-    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
-    getTemplateData(payload: TAugmentedPayload): Promise<TTemplateData>;
+interface CacheInstanceProps {
+    instanceName: string;
 }
-interface IEmailTemplatesCollection {
-    registerTemplate(id: string, template: IEmailTemplate<unknown, unknown, unknown>): void;
-    getTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload>(id: string): IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>;
-}
-type TemplatedEmailInput<TPayload> = {
-    from?: string;
-    to?: string[];
-    cc?: string[];
-    bcc?: string[];
-    subjectTemplate?: string;
-    templateId: string;
-    languageCode: string;
-    payload: TPayload;
-};
-interface HtmlEmailInput<TPayload> {
-    replyTo?: string;
-    from?: string;
-    to?: string[];
-    cc?: string[];
-    bcc?: string[];
-    subjectTemplate: string;
-    bodyTemplate: string;
-    payload: TPayload;
-}
-interface IEmailProvider<TTemplateData> {
-    sendTemplatedEmail<TPayload, TAugmentedPayload>(input: TemplatedEmailInput<TPayload>, template: IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>): Promise<void>;
-    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
-}
-interface IEmailLogger {
-    logTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
-    logHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
+declare const WpCacheInstance: (instanceName: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityActionsProps {
+    entityName: string;
 }
+declare const WpEntityActions: (entityName: string, props?: Omit<EntityActionsProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare class EntityManagerException extends Error {
-    constructor(message: string);
-}
-declare enum EntityOperationType {
-    Create = 0,
-    Update = 1,
-    Delete = 2,
-    Read = 3,
-    Search = 4,
-    Find = 5
-}
-declare abstract class EntityManagerUnauthorizedException extends EntityManagerException {
-    constructor(message: string);
-}
-declare class EntityOperationUnauthorizedException<TEntity> extends EntityManagerUnauthorizedException {
-    private readonly operation;
-    private readonly entity?;
-    constructor(operationType: EntityOperationType, entityName: string, entity?: DeepPartial<TEntity>);
-    get getEntity(): DeepPartial<TEntity> | undefined;
-    get getOperation(): EntityOperationType;
-}
-declare class EntityNotFoundException<TEntityId> extends EntityManagerException {
-    private readonly entityId;
-    constructor(id?: TEntityId);
-    getEntityId(): TEntityId | undefined;
-}
-declare class MultipleEntitiesFoundException extends EntityManagerException {
-    constructor();
+interface EntityAdapterProps {
+    entityName: string;
 }
-declare class EntityManagerConfigurationError extends EntityManagerException {
-    constructor(message: string);
+declare const WpEntityAdapter: (entityName: string, props?: Omit<EntityAdapterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityConnectorProps {
+    entityName: string;
 }
-declare class MissingEntityIdError extends EntityManagerException {
-    constructor();
+declare const WpEntityConnector: (entityName: string, props?: Omit<EntityConnectorProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityConverterProps {
+    entityName: string;
 }
+declare const WpEntityConverter: (entityName: string, props?: Omit<EntityConverterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-type FileData = {
-    content: Buffer;
-    contentType: string;
-    fileName: string;
-    folderPath: string;
-    metadata?: Record<string, any>;
-};
-type FileDownloadUrl = {
-    downloadUrl: string;
-    contentType: string;
-    fileName: string;
-};
-type FileReference = {
-    fileId: string;
-    reference: string;
-    providerId: string;
-};
-interface IFileManager {
-    uploadFile(file: FileData): Promise<FileReference>;
-    getFileContent(fileId: string): Promise<FileData>;
-    getFileDownloadUrl(fileId: string): Promise<FileDownloadUrl>;
+interface EmailTemplateProps {
+    templateId: string;
 }
-type FilesReferenceData = {
-    reference: string;
+declare const WpEmailTemplate: (templateId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+interface EmailProviderProps {
     providerId: string;
-    metadata?: Record<string, any>;
-    fileName: string;
-    filePath: string;
-    fileSize: number;
-    contentType: string;
-};
-type FileReferenceRecord = FilesReferenceData & {
-    fileId: string;
-    createdOn: Date;
-    updatedOn: Date;
-};
-interface IFilesReferenceRepository {
-    getReference(fileId: string): Promise<FileReferenceRecord>;
-    createReference(file: FilesReferenceData): Promise<FileReferenceRecord>;
-    updateReference(fileId: string, file: FilesReferenceData): Promise<FileReferenceRecord>;
-    deleteReference(fileId: string): Promise<void>;
 }
-type FileProviderReference = {
-    reference: string;
-};
-type FileProviderUploadData = {
-    fileName: string;
-    content: Buffer;
-    contentType: string;
-};
-type FileProviderDownloadData = {
-    content: Buffer;
-};
-type FileProviderDownloadUrl = {
-    downloadUrl: string;
-};
-interface IFileProvider {
-    getProviderId(): string;
-    uploadFile(file: FileProviderUploadData): Promise<FileProviderReference>;
-    deleteFile(reference: FileProviderReference): Promise<void>;
-    downloadFile(reference: FileProviderReference): Promise<FileProviderDownloadData>;
-    getFileProviderDownloadUrl(reference: FileProviderReference): Promise<FileProviderDownloadUrl>;
+declare const WpEmailProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+interface EmailLoggerProps {
 }
+declare const WpEmailLogger: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-type FilterExpression<TEntity> = (entity: TEntity) => boolean;
-
-type LocalizedMap<T> = {
-    [key: string]: T;
+type EntityVersioningOptions = {
+    enabled: boolean;
 };
-type LocalizedTexts = LocalizedMap<string>;
-
-interface IEventLog<TPayload> {
-    type: string;
-    payload?: TPayload;
-    userId?: string;
-    userName?: string;
-    timestamp: Date;
-}
-interface IEventsTracker<TEventLog extends IEventLog<unknown>> {
-    track(log: TEventLog): Promise<void>;
+interface EntityProps {
+    name: string;
+    versioning?: EntityVersioningOptions;
 }
+declare const WpEntity: (name: string, props?: Omit<EntityProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface IEntitySeedEntry<TEntity, TFindCondition> {
-    identifier: TFindCondition;
-    data: () => Partial<TEntity>;
+interface FileProviderProps {
+    providerId: string;
 }
-interface IEntitySeeder {
-    execute(): Promise<void>;
-    get priority(): number | undefined;
+declare const WpFileProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+interface FileReferenceRepositoryProps {
 }
+declare const WpFileReferenceRepository: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare abstract class EntitySeeder<TEntity, TFindCondition> implements IEntitySeeder {
-    protected readonly logger: _punks_backend_core.ILogger;
-    execute(): Promise<void>;
-    protected abstract getEntries(): Promise<IEntitySeedEntry<TEntity, TFindCondition>[]>;
-    protected abstract exists(condition: TFindCondition): Promise<boolean>;
-    protected abstract create(entity: Partial<TEntity>): Promise<void>;
-    abstract get priority(): number | undefined;
+interface AppInitializerProps {
+    priority?: number;
 }
+declare const WpAppInitializer: (props?: AppInitializerProps) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare abstract class EntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem, TContext, TPayload = unknown> implements IEntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem> {
-    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
-    private readonly logger;
-    protected readonly entityName: string;
-    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    export(filters?: TEntitySearchParameters): Promise<TSheetItem[]>;
-    import(items: TSheetItem[], payload?: TPayload): Promise<void>;
-    parse(data: Buffer, format: EntitySerializationFormat): Promise<ImportEntry<TSheetItem, TEntityId>[]>;
-    private parseCsv;
-    private parseXlsx;
-    private convertSheetRecord;
-    private parseColumnValue;
-    createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
-    private buildSampleFile;
-    serialize(data: TSheetItem[], format: EntitySerializationFormat): Promise<EntityExportFile>;
-    protected abstract getDefinition(context: TContext): Promise<EntitySerializerSheetDefinition<TSheetItem>>;
-    protected abstract loadEntities(filters?: TEntitySearchParameters): Promise<TEntity[]>;
-    protected abstract convertToSheetItems(entities: TEntity[]): Promise<TSheetItem[]>;
-    protected abstract importItem(item: TSheetItem, context: TContext, payload?: TPayload): Promise<EntityReference<TEntityId>>;
-    protected getContext(): Promise<TContext>;
-    private buildExportFile;
-    private getColumnValue;
-    private buildExportFileName;
+interface EntityRepositoryProps {
+    entityName: string;
 }
+declare const WpEntityRepository: (entityName: string, props?: Omit<EntityRepositoryProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare abstract class EntitySnapshotService<TEntityId, TEntitySnapshot> implements IEntitySnapshotService<TEntityId, TEntitySnapshot> {
-    protected readonly entityName: string;
-    constructor(entityName: string);
-    abstract getSnapshot(id: TEntityId): Promise<TEntitySnapshot>;
+interface EntityManagerProps {
+    entityName: string;
 }
+declare const WpEntityManager: (entityName: string, props?: Omit<EntityManagerProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare const createContainer: () => IEntityManagerServiceRoot;
+interface EntityQueryBuilderProps {
+    entityName: string;
+}
+declare const WpEntityQueryBuilder: (entityName: string, props?: Omit<EntityQueryBuilderProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare const toEntitiesImportInput: <TPayload>(request: {
-    format: EntitySerializationFormat;
-    file: Express.Multer.File;
-    payload?: TPayload | undefined;
-}) => EntitiesImportInput<TPayload>;
+interface PipelineTemplateProps {
+    name: string;
+}
+declare const WpPipeline: (name: string, props?: Omit<PipelineTemplateProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare const PLATFORM_EVENT_NAMESPACE = "platform";
-declare const PlatformEvents: {
-    Messaging: {
-        EmailSent: string;
-    };
-};
+interface EntitySeederProps {
+    entityName: string;
+    priority?: number;
+}
+declare const WpEntitySeeder: (entityName: string, props?: Omit<EntitySeederProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface MessagingEmailSentPayload {
-    from?: string;
-    to?: string[];
-    cc?: string[];
-    bcc?: string[];
-    subject?: string;
-    body?: string;
-    payload?: any;
-    request?: any;
+interface EntitySerializerProps {
+    entityName: string;
 }
+declare const WpEntitySerializer: (entityName: string, props?: Omit<EntitySerializerProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface ICacheDatabaseItem {
-    id: string;
-    instance: string;
-    key: string;
-    data: any;
-    createdOn: Date;
-    updatedOn: Date;
-    expirationTime: Date;
+interface EntitySnapshotServiceProps {
+    entityName: string;
 }
+declare const WpEntitySnapshotService: (entityName: string, props?: Omit<EntitySnapshotServiceProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare abstract class TypeormCacheInstance<TEntity extends ICacheDatabaseItem> implements ICacheInstance {
-    protected readonly instanceName: string;
-    private readonly logger;
-    constructor(instanceName: string);
-    getInstanceName(): string;
-    getEntries(): Promise<CacheEntryInfo[]>;
-    getEntry(key: string): Promise<CacheEntryDetail | undefined>;
-    retrieve<T>(key: string, input: {
-        ttl: CacheTtl;
-        valueFactory: () => Promise<T>;
-    }): Promise<T>;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, { ttl, value }: {
-        value: T;
-        ttl: CacheTtl;
-    }): Promise<void>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-    protected abstract getRepository(): Repository<TEntity>;
+declare const EntityManagerSymbols: {
+    GlobalAuthenticationMiddleware: symbol;
+    AppInitializer: symbol;
+    EventsTracker: symbol;
+    Entity: symbol;
+    EntityActions: symbol;
+    EntityAdapter: symbol;
+    EntityAuthMiddleware: symbol;
+    EntityRepository: symbol;
+    EntityConnector: symbol;
+    EntityConverter: symbol;
+    EntitySerializer: symbol;
+    EntitySnapshotService: symbol;
+    EntityManager: symbol;
+    EntityQueryBuilder: symbol;
+    EntitySeeder: symbol;
+    EntityVersioningProvider: symbol;
+    EmailProvider: symbol;
+    EmailTemplate: symbol;
+    EmailLogger: symbol;
+    BucketProvider: symbol;
+    FileProvider: symbol;
+    FileReferenceRepository: symbol;
+    PipelineTemplate: symbol;
+    CacheInstance: symbol;
+};
+
+interface EventsTrackerProps {
+    disabled?: boolean;
 }
+declare const WpEventsTracker: (props?: EventsTrackerProps) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare class PipelineController implements IPipelinesController {
-    createInstance<TInput, TOutput, TContext>(definition: PipelineDefinition<TInput, TOutput, TContext>, input: TInput, context: TContext): Promise<IPipelineInstance<TInput, TOutput, TContext>>;
+interface EntityVersioningProviderProps {
+    disabled?: boolean;
 }
+declare const WpEntityVersioningProvider: (props?: EntityVersioningProviderProps) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare enum QueryBuilderOperation {
-    Search = "search",
-    Get = "get"
+interface DiscoveredModule<T = object> {
+    name: string;
+    instance: T;
+    injectType?: Function | Type$1<any>;
+    dependencyType: Type$1<T>;
 }
-declare abstract class QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext> {
-    abstract get(id: TEntityId, context?: IAuthenticationContext<TUserContext> | undefined): Promise<TEntity | undefined>;
-    abstract exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
-    abstract count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
-    abstract delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;
-    abstract search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
-    abstract find(request: {
-        filters?: TEntitySearchParameters["filters"];
-        sorting?: TEntitySearchParameters["sorting"];
-    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
-    protected getIndexBasedPagingResult({ paging, totResults, currentPageResults, }: {
-        paging?: ISearchRequestPaging<number>;
-        totResults: number;
-        currentPageResults: number;
-    }): IEntitiesSearchResultsPaging<number> | undefined;
+interface DiscoveredClass extends DiscoveredModule {
+    parentModule?: DiscoveredModule;
+}
+interface DiscoveredMethod {
+    handler: (...args: any[]) => any;
+    methodName: string;
+    parentClass: DiscoveredClass;
+}
+interface DiscoveredMethodWithMeta<T> {
+    discoveredMethod: DiscoveredMethod;
+    meta: T;
+}
+interface DiscoveredClassWithMeta<T> {
+    discoveredClass: DiscoveredClass;
+    meta: T;
+}
+type MetaKey = string | number | symbol;
+type Filter<T> = (item: T) => boolean;
+declare class ModulesContainerProvider {
+    private modulesContainer;
+    setModulesContainer(modulesContainer: ModulesContainer): void;
+    getModules(): [string, Module][];
+}
+declare class CustomDiscoveryService {
+    private readonly modulesContainer;
+    private readonly metadataScanner;
+    private discoveredControllers?;
+    private discoveredProviders?;
+    constructor(modulesContainer: ModulesContainerProvider, metadataScanner: MetadataScanner);
+    /**
+     * Discovers all providers in a Nest App that match a filter
+     * @param filter
+     */
+    providers(filter: Filter<DiscoveredClass>): Promise<DiscoveredClass[]>;
+    /**
+     * Discovers all controller methods that either directly have a certain meta key attached to them
+     * or belong to a controller that has the same meta key attached to them
+     * @param metaKey The meta key to scan for
+     * @param metaFilter An optional filter for the contents of the meta object
+     */
+    methodsAndControllerMethodsWithMetaAtKey<T>(metaKey: MetaKey, metaFilter?: Filter<T>): Promise<DiscoveredMethodWithMeta<T>[]>;
+    /**
+     * Discovers all providers in an App that have meta at a specific key and returns the provider(s) and associated meta
+     * @param metaKey The metakey to scan for
+     */
+    providersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
+    providerWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T> | undefined>;
+    /**
+     * Discovers all controllers in a Nest App that match a filter
+     * @param filter
+     */
+    controllers(filter: Filter<DiscoveredClass>): Promise<DiscoveredClass[]>;
+    /**
+     * Discovers all controllers in an App that have meta at a specific key and returns the controller(s) and associated meta
+     * @param metaKey The metakey to scan for
+     */
+    controllersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
+    /**
+     * Discovers all method handlers matching a particular metakey from a Provider or Controller
+     * @param component
+     * @param metaKey
+     */
+    classMethodsWithMetaAtKey<T>(component: DiscoveredClass, metaKey: MetaKey): DiscoveredMethodWithMeta<T>[];
+    /**
+     * Discovers all the methods that exist on providers in a Nest App that contain metadata under a specific key
+     * @param metaKey The metakey to scan for
+     * @param providerFilter A predicate used to limit the providers being scanned. Defaults to all providers in the app module
+     */
+    providerMethodsWithMetaAtKey<T>(metaKey: MetaKey, providerFilter?: Filter<DiscoveredClass>): Promise<DiscoveredMethodWithMeta<T>[]>;
+    /**
+     * Discovers all the methods that exist on controllers in a Nest App that contain metadata under a specific key
+     * @param metaKey The metakey to scan for
+     * @param controllerFilter A predicate used to limit the controllers being scanned. Defaults to all providers in the app module
+     */
+    controllerMethodsWithMetaAtKey<T>(metaKey: MetaKey, controllerFilter?: Filter<DiscoveredClass>): Promise<DiscoveredMethodWithMeta<T>[]>;
+    private toDiscoveredClass;
+    private extractMethodMetaAtKey;
+    private discover;
+    private getModuleEntries;
 }
 
-type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
-type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
-declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
-    protected readonly innerRepository: Repository<TEntity>;
+declare class EntityManagerRegistry {
+    private readonly container;
+    getContainer(): IEntityManagerServiceRoot;
+    registerGlobalServices({ eventEmitter, }: {
+        eventEmitter?: IEventEmitter;
+    }): Promise<void>;
+    registerDiscoveredEntity(app: INestApplicationContext, { adapter, entityName, entity, converter, queryBuilder, repository, authMiddleware, serializer, snapshotService, settings, }: {
+        entityName: string;
+        entity: DiscoveredClassWithMeta<EntityProps>;
+        repository: DiscoveredClassWithMeta<EntityRepositoryProps>;
+        converter: DiscoveredClassWithMeta<EntityConverterProps>;
+        adapter: DiscoveredClassWithMeta<EntityAdapterProps>;
+        queryBuilder: DiscoveredClassWithMeta<EntityQueryBuilderProps>;
+        serializer: DiscoveredClassWithMeta<EntitySerializerProps>;
+        snapshotService?: DiscoveredClassWithMeta<EntitySnapshotServiceProps>;
+        authMiddleware?: DiscoveredClassWithMeta<EntityAuthMiddlewareProps>;
+        settings: EntityManagerSettings;
+    }): Promise<void>;
+    resolveEntityServicesCollection<TEntity>(entityName: string): EntityServiceLocator<TEntity, unknown>;
+}
+
+declare abstract class NestEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
+    protected readonly services: EntityServiceLocator<TEntity, unknown>;
+    private actionsInstance;
+    constructor(entityName: string, registry: EntityManagerRegistry);
+    protected get converter(): IEntityConverter<TEntity, TEntityDto, TEntityListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
+    get manager(): IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+}
+
+declare abstract class NestEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
+    protected readonly services: EntityServiceLocator<TEntity, unknown>;
+    private managerInstance;
+    constructor(entityName: string, registry: EntityManagerRegistry);
+    get manager(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    getRepository<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(): TRepository;
+}
+
+declare abstract class EntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem, TContext, TPayload = unknown> implements IEntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem> {
+    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
     private readonly logger;
-    constructor(innerRepository: Repository<TEntity>);
-    getInnerRepository(): Repository<TEntity>;
-    distinct<TField extends keyof TEntity, TValue>(field: TField, condition: FindManyOptions<TEntity>): Promise<any[]>;
-    exists(id: TEntityId): Promise<boolean>;
-    existsBy(condition: FindOneOptions<TEntity>): Promise<boolean>;
-    get(id: TEntityId, options?: {
-        relations?: FindOptionsRelations<TEntity>;
-    }): Promise<TEntity | undefined>;
-    getBy(condition: FindOneOptions<TEntity>): Promise<TEntity | undefined>;
-    all(): Promise<TEntity[]>;
-    count(condition: FindManyOptions<TEntity>): Promise<number>;
-    find(condition: FindManyOptions<TEntity>): Promise<TEntity[]>;
-    findById(id: TEntityId[]): Promise<TEntity[]>;
-    delete(id: TEntityId): Promise<void>;
-    deleteBy(condition: DeleteCriteria<TEntity>): Promise<IEntitiesDeleteResult>;
-    create(entity: Partial<TEntity>): Promise<TEntity>;
-    update(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
-    updateBy(entity: Partial<TEntity>, condition: UpdateCriteria<TEntity>): Promise<TEntity[]>;
-    upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+    protected readonly entityName: string;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    export(filters?: TEntitySearchParameters): Promise<TSheetItem[]>;
+    import(items: TSheetItem[], payload?: TPayload): Promise<void>;
+    parse(data: Buffer, format: EntitySerializationFormat): Promise<ImportEntry<TSheetItem, TEntityId>[]>;
+    private parseCsv;
+    private parseXlsx;
+    private convertSheetRecord;
+    private parseColumnValue;
+    createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
+    private buildSampleFile;
+    serialize(data: TSheetItem[], format: EntitySerializationFormat): Promise<EntityExportFile>;
+    protected abstract getDefinition(context: TContext): Promise<EntitySerializerSheetDefinition<TSheetItem>>;
+    protected abstract loadEntities(filters?: TEntitySearchParameters): Promise<TEntity[]>;
+    protected abstract convertToSheetItems(entities: TEntity[]): Promise<TSheetItem[]>;
+    protected abstract importItem(item: TSheetItem, context: TContext, payload?: TPayload): Promise<EntityReference<TEntityId>>;
+    protected getContext(): Promise<TContext>;
+    private buildExportFile;
+    private getColumnValue;
+    private buildExportFileName;
 }
 
-type NumericFilter = {
-    in?: number[];
-    eq?: number;
-    gt?: number;
-    gte?: number;
-    lt?: number;
-    lte?: number;
+declare abstract class NestEntitySerializer<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TSheetItem, TContext, TPayload = unknown> extends EntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem, TContext, TPayload> {
+    private readonly registry;
+    constructor(entityName: string, registry: EntityManagerRegistry);
+    protected get manager(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, any, TEntitySearchParameters, TSorting, TCursor, any>;
+}
+
+declare abstract class EntitySnapshotService<TEntityId, TEntitySnapshot> implements IEntitySnapshotService<TEntityId, TEntitySnapshot> {
+    protected readonly entityName: string;
+    constructor(entityName: string);
+    abstract getSnapshot(id: TEntityId): Promise<TEntitySnapshot>;
+}
+
+declare abstract class NestEntitySnapshotService<TEntity, TEntityId, TEntityRepository, TEntitySnapshot> extends EntitySnapshotService<TEntityId, TEntitySnapshot> {
+    protected readonly services: EntityServiceLocator<TEntity, unknown>;
+    constructor(entityName: string, registry: EntityManagerRegistry);
+    get repository(): TEntityRepository;
+}
+
+interface IAuthService {
+}
+interface IAuthRole {
+    id: string;
+    uid: string;
+    name: string;
+}
+interface IAuthPermission {
+    id: string;
+    uid: string;
+    name: string;
+}
+interface IAuthOrganizationalUnit {
+    id: string;
+    uid: string;
+    name: string;
+}
+interface IAuthUserProfile {
+    firstName: string;
+    lastName: string;
+}
+interface IAuthUserTenant {
+    id: string;
+    uid: string;
+    name: string;
+}
+interface IAuthUserOrganization {
+    id: string;
+    uid: string;
+    name: string;
+    tenant: IAuthUserTenant;
+}
+interface IAuthUser {
+    id: string;
+    passwordHash: string;
+    passwordUpdateTimestamp?: Date;
+    temporaryPassword: boolean;
+    userName: string;
+    email: string;
+    verified: boolean;
+    verifiedTimestamp?: Date;
+    disabled: boolean;
+    profile: IAuthUserProfile;
+    organization?: IAuthUserOrganization;
+}
+interface IAuthUserContext {
+    organizationUid?: string;
+}
+interface IAuthUserTokenData<TContext extends IAuthUserContext> {
+    userId: string;
+    email: string;
+    context?: TContext;
+}
+interface IAuthUserService<TUser extends IAuthUser, TUserContext extends IAuthUserContext, TUserRegistrationInfo> {
+    getById(id: string): Promise<TUser>;
+    getByEmail(email: string, context?: TUserContext): Promise<TUser>;
+    getByUserName(userName: string, context?: TUserContext): Promise<TUser>;
+    update(id: string, data: Partial<TUser>): Promise<void>;
+    delete(id: string): Promise<void>;
+    create(email: string, userName: string, data: TUserRegistrationInfo, context?: TUserContext): Promise<TUser>;
+}
+interface IAuthRoleService<TRole extends IAuthRole, TPermission extends IAuthPermission> {
+    create(data: Partial<TRole>): Promise<TRole>;
+    update(id: string, data: Partial<TRole>): Promise<void>;
+    ensure(uid: string, data: Partial<Omit<TRole, "uid">>): Promise<TRole>;
+    delete(id: string): Promise<void>;
+    getById(id: string): Promise<TRole | undefined>;
+    getByUid(uid: string): Promise<TRole | undefined>;
+    addPermission(uid: string, permissionUid: string): Promise<void>;
+    removePermission(uid: string, permissionUid: string): Promise<void>;
+    getPermissions(uid: string): Promise<TPermission[]>;
+}
+interface IAuthPermissionService<TPermission extends IAuthPermission> {
+    create(data: Partial<TPermission>): Promise<TPermission>;
+    update(id: string, data: Partial<TPermission>): Promise<void>;
+    ensure(uid: string, data: Partial<Omit<TPermission, "uid">>): Promise<TPermission>;
+    delete(id: string): Promise<void>;
+    getById(id: string): Promise<TPermission | undefined>;
+    getByUid(uid: string): Promise<TPermission | undefined>;
+}
+interface IAuthUserRolesService<TUser extends IAuthUser, TRole extends IAuthRole, TPermission extends IAuthPermission, TOrganizationalUnit extends IAuthOrganizationalUnit> {
+    getRoleUsers(roleId: string): Promise<TUser[]>;
+    getUserRoles(userId: string): Promise<TRole[]>;
+    getUserPermissions(userId: string): Promise<TPermission[]>;
+    getUserOrganizationalUnits(userId: string): Promise<TOrganizationalUnit[]>;
+    addUserToRole(userId: string, roleId: string): Promise<void>;
+    addUserToRoleByUid(userId: string, roleUid: string): Promise<void>;
+    removeUserFromRole(userId: string, roleId: string): Promise<void>;
+    removeUserFromRoleByUid(userId: string, roleUid: string): Promise<void>;
+    clearUserRoles(userId: string): Promise<void>;
+}
+
+type CurrentUserData = {
+    user: IAuthUser;
+    roles: IAuthRole[];
+    permissions: IAuthPermission[];
+    organizationalUnits: IAuthOrganizationalUnit[];
 };
-type StringFilter = {
-    gt?: string;
-    gte?: string;
-    lt?: string;
-    lte?: string;
-    in?: string[];
-    eq?: string;
-    like?: string;
-    ne?: string;
-    notIn?: string[];
-    notLike?: string;
+declare const CurrentUser: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+interface AuthenticationModuleSettings {
+    passwordSalt: string;
+    jwtSecret: string;
+}
+type UserPasswordResetTokenPayload = {
+    userId: string;
+    email: string;
+    timestamp: number;
 };
-type EnumFilter<T> = {
-    in?: T[];
-    eq?: T;
-    ne?: T;
-    notIn?: T[];
+type EmailVerifyTokenPayload = {
+    userId: string;
+    email: string;
+    timestamp: number;
+};
+declare enum UserRegistrationError {
+    UserAlreadyExists = "userAlreadyExists"
+}
+type AppRole = {
+    uid: string;
+    name: string;
+};
+type AppPermission = {
+    uid: string;
+    name: string;
+};
+type RolesGuardOptions = {
+    exact?: boolean;
+};
+
+declare const Public: () => _nestjs_common.CustomDecorator<string>;
+declare const Authenticated: () => _nestjs_common.CustomDecorator<string>;
+declare const Permissions: (...permissions: string[]) => _nestjs_common.CustomDecorator<string>;
+declare const Roles: (...roles: string[]) => _nestjs_common.CustomDecorator<string>;
+declare const MemberOf: (...groups: string[]) => _nestjs_common.CustomDecorator<string>;
+declare const buildRolesGuard: ({ mainRole, secondaryRoles, }: {
+    mainRole: AppRole;
+    secondaryRoles?: AppRole[] | undefined;
+}, options?: RolesGuardOptions) => _nestjs_common.CustomDecorator<string>;
+declare const buildPermissionsGuard: ({ permissions, }: {
+    permissions: AppPermission[];
+}) => _nestjs_common.CustomDecorator<string>;
+
+declare const WpPermissionsService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+declare const AuthenticationExtensionSymbols: {
+    UserService: symbol;
+    RolesService: symbol;
+    PermissionsService: symbol;
+    UserRolesService: symbol;
+};
+
+declare const WpRolesService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+declare const WpUserService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+declare const WpUserRolesService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+declare const AuthenticationEmailTemplates: {
+    Registration: string;
+    PasswordReset: string;
+    EmailVerify: string;
+};
+type RegistrationEmailPayload = {
+    firstName: string;
+    lastName: string;
+    callbackUrl: string;
 };
-type BooleanFilter = {
-    eq?: boolean;
-    ne?: boolean;
+type EmailVerifyEmailPayload = {
+    firstName: string;
+    lastName: string;
+    callbackUrl: string;
 };
-type DateFilter = {
-    in?: Date[];
-    eq?: Date;
-    gt?: Date;
-    gte?: Date;
-    lt?: Date;
-    lte?: Date;
+type PasswordResetEmailPayload = {
+    firstName: string;
+    lastName: string;
+    callbackUrl: string;
 };
 
-declare class QueryClauseBuilder {
-    enumFilter<T>(filter: EnumFilter<T>): FindOperator<T>;
-    stringFilter(filter: StringFilter): FindOperator<string>;
-    numericFilter(filter: NumericFilter): FindOperator<number>;
-    dateFilter(filter: DateFilter): FindOperator<Date>;
-    boolFilter(filter: BooleanFilter): FindOperator<boolean>;
+declare class AuthenticationError extends Error {
+    constructor(message: string);
+}
+declare class InvalidCredentialsError extends AuthenticationError {
+    constructor(message: string);
+}
+declare class OperationTokenMismatchError extends AuthenticationError {
+    constructor(message: string);
 }
 
-type FacetValueType<T> = {
-    value: T;
-    count: number;
-};
-type FacetType<T> = {
-    values: FacetValueType<T>[];
+declare const AUTHENTICATION_EVENTS_NAMESPACE = "authentication";
+declare const AuthenticationEvents: {
+    UserLogin: string;
+    UserRegistrationStarted: string;
+    UserRegistrationCompleted: string;
+    UserPasswordResetStarted: string;
+    UserPasswordResetCompleted: string;
 };
-type StringFacetsType = FacetType<string>;
-type NumberFacetsType = FacetType<number>;
-type BooleanFacetsType = FacetType<boolean>;
 
-type ChildrenMap = Record<string, {
-    count: number;
-}>;
+type UserProfile = {
+    firstName: string;
+    lastName: string;
+};
+type UserLoginEventPayload = {
+    userId: string;
+    email: string;
+    profile: UserProfile;
+};
+type UserRegistrationStartedEventPayload = {
+    email: string;
+    profile: UserProfile;
+};
+type UserRegistrationCompletedEventPayload = {
+    userId: string;
+    email: string;
+    profile: UserProfile;
+};
+type UserPasswordResetStartedEventPayload = {
+    email: string;
+};
+type UserPasswordResetCompletedEventPayload = {
+    userId: string;
+    email: string;
+    profile: UserProfile;
+};
 
-declare class PermissionsChecker<TUserContext> {
-    hasPermission(context: IAuthenticationContext<TUserContext>, permissions: string[]): boolean;
+declare class AuthGuard implements CanActivate {
+    private reflector;
+    private readonly logger;
+    constructor(reflector: Reflector);
+    canActivate(context: ExecutionContext): boolean;
+    private isRoleMatching;
+    private isPermissionMatching;
+    private getIsForAllAuthenticated;
+    private getIsPublic;
+    private getAllowedRoles;
+    private getAllowedPermissions;
+    private getCurrentAuth;
+    private getMetadata;
+    private getContextInfo;
 }
 
-type FacetRelations = {
-    columns: string[];
-};
-declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
-    private readonly services;
-    private repository;
-    protected clause: QueryClauseBuilder;
-    protected permissions: PermissionsChecker<TUserContext>;
-    constructor(services: EntityServiceLocator<TEntity, unknown>);
-    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
-    exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
-    count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
-    delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;
-    find(request: {
-        filters?: TEntitySearchParameters["filters"];
-        sorting?: TEntitySearchParameters["sorting"];
-    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
-    search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, number, TFacets>>;
-    protected getFieldDistinctValues<T>(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<T[]>;
-    protected findPagedQueryResults(request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<TEntity[]>;
-    protected getRelationsToLoad(request: TEntitySearchParameters | undefined, context: IAuthenticationContext<TUserContext> | undefined, operation: QueryBuilderOperation): FindOptionsRelations<TEntity> | undefined;
-    protected buildPagingParameters(request: TEntitySearchParameters): {
-        skip: number | undefined;
-        take: number | undefined;
-    };
-    protected countQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<number>;
-    protected abstract buildSortingClause(request: TEntitySearchParameters): FindOptionsOrder<TEntity>;
-    protected abstract buildWhereClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
-    protected buildTextSearchClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
-    protected abstract buildContextFilter(context?: IAuthenticationContext<TUserContext>): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
-    protected abstract calculateFacets(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TFacets>;
-    protected calculateChildrenMap(items: TEntity[]): Promise<ChildrenMap>;
-    protected queryChildrenMap<TField extends keyof TEntity>({ nodeIds, idField, parentField, }: {
-        nodeIds: string[];
-        idField: TField;
-        parentField: TField;
-    }): Promise<ChildrenMap>;
-    protected calculateFacet<TField extends keyof TEntity, TValue>(field: TField, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<FacetType<TValue>>;
-    protected calculateStringFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<StringFacetsType>;
-    protected calculateNumericFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<NumberFacetsType>;
-    protected calculateBooleanFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<BooleanFacetsType>;
-    protected getRepository(): TypeOrmRepository<TEntity, unknown>;
-    private buildSearchRelations;
-    private buildWhere;
-    private mergeWhereClauses;
-    private mergeWheres;
+declare enum UserCreationError {
+    UserAlreadyExists = "userAlreadyExists"
 }
-
-declare abstract class NestEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext> implements IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> {
-    abstract canSearch(context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    abstract canRead(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    abstract canCreate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    abstract canUpdate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    abstract canDelete(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    abstract canDeleteItems(context: TAuthenticationContext): Promise<IAuthorizationResult>;
+interface UserCreationInput<TUserRegistrationInfo, TUserContext extends IAuthUserContext> {
+    email: string;
+    userName: string;
+    password: string;
+    registrationInfo: TUserRegistrationInfo;
+    context?: TUserContext;
 }
-
-interface EntityAuthMiddlewareProps {
-    entityName: string;
+interface UserCreationResult {
+    success: boolean;
+    error?: UserCreationError;
+    userId?: string;
 }
-declare const WpEntityAuthMiddleware: (entityName: string, props?: Omit<EntityAuthMiddlewareProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface GlobalAuthenticationMiddlewareProps {
-    name: string;
-    weight?: number;
+interface UserDisableInput {
+    userId: string;
 }
-declare const WpGlobalAuthenticationMiddleware: (name: string, props?: Omit<GlobalAuthenticationMiddlewareProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface BucketProviderProps {
-    providerId: string;
+interface UserDeleteInput {
+    userId: string;
 }
-declare const WpBucketProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface CacheInstanceProps {
-    instanceName: string;
+interface UserEnableInput {
+    userId: string;
 }
-declare const WpCacheInstance: (instanceName: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntityActionsProps {
-    entityName: string;
+interface UserLoginInput<TUserContext extends IAuthUserContext> {
+    userName: string;
+    password: string;
+    context?: TUserContext;
 }
-declare const WpEntityActions: (entityName: string, props?: Omit<EntityActionsProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-
-interface EntityAdapterProps {
-    entityName: string;
+interface UserLoginResult {
+    token?: string;
+    success: boolean;
 }
-declare const WpEntityAdapter: (entityName: string, props?: Omit<EntityAdapterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntityConnectorProps {
-    entityName: string;
+interface UserPasswordChangeInput {
+    userId: string;
+    newPassword: string;
+    temporary: boolean;
 }
-declare const WpEntityConnector: (entityName: string, props?: Omit<EntityConnectorProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntityConverterProps {
-    entityName: string;
+interface UserPasswordResetCompleteInput {
+    token: string;
+    newPassword: string;
+    temporary?: boolean;
 }
-declare const WpEntityConverter: (entityName: string, props?: Omit<EntityConverterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EmailTemplateProps {
-    templateId: string;
-}
-declare const WpEmailTemplate: (templateId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-interface EmailProviderProps {
-    providerId: string;
+type UserPasswordResetRequestCallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
+interface UserPasswordResetRequestInput<TUserContext extends IAuthUserContext> {
+    email: string;
+    callback: UserPasswordResetRequestCallbackTemplate;
+    languageCode: string;
+    context?: TUserContext;
 }
-declare const WpEmailProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-interface EmailLoggerProps {
+interface UserPasswordResetRequestResult {
+    success: boolean;
 }
-declare const WpEmailLogger: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-type EntityVersioningOptions = {
-    enabled: boolean;
+type UserRegisterCallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
 };
-interface EntityProps {
-    name: string;
-    versioning?: EntityVersioningOptions;
+interface UserRegistrationInput<TUserRegistrationInfo, TUserContext extends IAuthUserContext> {
+    email: string;
+    userName: string;
+    password: string;
+    registrationInfo: TUserRegistrationInfo;
+    callback: UserRegisterCallbackTemplate;
+    languageCode: string;
+    context?: TUserContext;
+}
+interface UserRegistrationResult {
+    success: boolean;
+    error?: UserRegistrationError;
+    userId?: string;
 }
-declare const WpEntity: (name: string, props?: Omit<EntityProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface FileProviderProps {
-    providerId: string;
+interface UserTokenVerifyResult<TUserContext extends IAuthUserContext> {
+    isValid: boolean;
+    data: IAuthUserTokenData<TUserContext>;
 }
-declare const WpFileProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-interface FileReferenceRepositoryProps {
+interface UserTokenVerifyInput {
+    token: string;
 }
-declare const WpFileReferenceRepository: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface AppInitializerProps {
-    priority?: number;
+interface UserVerifyCompleteInput {
+    token: string;
 }
-declare const WpAppInitializer: (props?: AppInitializerProps) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntityRepositoryProps {
-    entityName: string;
+interface UserVerifyRequestInput<TUserContext extends IAuthUserContext> {
+    email: string;
+    callback: UserVerifyRequestCallbackTemplate;
+    languageCode: string;
+    context?: TUserContext;
 }
-declare const WpEntityRepository: (entityName: string, props?: Omit<EntityRepositoryProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+interface UserVerifyRequestResult {
+    success: boolean;
+}
+type UserVerifyRequestCallbackTemplate = {
+    urlTemplate: string;
+    tokenPlaceholder: string;
+};
 
-interface EntityManagerProps {
-    entityName: string;
+declare class AppSessionService {
+    getValue<T>(key: string): T;
+    setValue<T>(key: string, value: T): void;
+    clearValue(key: string): void;
+    getRequest(): express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+    retrieveRequest(): express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>> | undefined;
+    private retrieveSession;
+    private getSession;
 }
-declare const WpEntityManager: (entityName: string, props?: Omit<EntityManagerProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntityQueryBuilderProps {
-    entityName: string;
+declare class AppHashingService {
+    hash(value: string, salt: string): Promise<string>;
+    compare(hash: string, value: string, salt: string): Promise<boolean>;
 }
-declare const WpEntityQueryBuilder: (entityName: string, props?: Omit<EntityQueryBuilderProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface PipelineTemplateProps {
-    name: string;
+declare class EntityManagerService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
+    getActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
+    getRepository<TEntity>(entityName: string): IEntityRepository<TEntity, unknown, unknown, unknown, unknown, unknown>;
 }
-declare const WpPipeline: (name: string, props?: Omit<PipelineTemplateProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntitySeederProps {
-    entityName: string;
-    priority?: number;
+declare class EmailService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    sendTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
+    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
+    private getTemplate;
+    private get templates();
+    private get provider();
+    private get logger();
 }
-declare const WpEntitySeeder: (entityName: string, props?: Omit<EntitySeederProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntitySerializerProps {
-    entityName: string;
+declare class CacheService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    getInstance(instanceName: string): ICacheInstance;
+    getInstances(): ICacheInstance[];
 }
-declare const WpEntitySerializer: (entityName: string, props?: Omit<EntitySerializerProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntitySnapshotServiceProps {
-    entityName: string;
+declare class FilesService implements IFileManager {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    uploadFile(file: FileData): Promise<FileReference>;
+    getFileContent(fileId: string): Promise<FileData>;
+    getFileDownloadUrl(fileId: string): Promise<FileDownloadUrl>;
+    private getFileProvider;
+    private get defaultFileProvider();
+    private get referencesRepo();
 }
-declare const WpEntitySnapshotService: (entityName: string, props?: Omit<EntitySnapshotServiceProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-declare const EntityManagerSymbols: {
-    GlobalAuthenticationMiddleware: symbol;
-    AppInitializer: symbol;
-    EventsTracker: symbol;
-    Entity: symbol;
-    EntityActions: symbol;
-    EntityAdapter: symbol;
-    EntityAuthMiddleware: symbol;
-    EntityRepository: symbol;
-    EntityConnector: symbol;
-    EntityConverter: symbol;
-    EntitySerializer: symbol;
-    EntitySnapshotService: symbol;
-    EntityManager: symbol;
-    EntityQueryBuilder: symbol;
-    EntitySeeder: symbol;
-    EntityVersioningProvider: symbol;
-    EmailProvider: symbol;
-    EmailTemplate: symbol;
-    EmailLogger: symbol;
-    BucketProvider: symbol;
-    FileProvider: symbol;
-    FileReferenceRepository: symbol;
-    PipelineTemplate: symbol;
-    CacheInstance: symbol;
+type IEventData<TEventPayload> = {
+    payload?: TEventPayload;
+    userId?: string;
+    userName?: string;
+    timestamp?: Date;
 };
-
-interface EventsTrackerProps {
-    disabled?: boolean;
+declare class EventsService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    emitEvent<TEventPayload>(eventName: string, eventData: IEventData<TEventPayload>): Promise<void>;
+    private buildPayload;
+    private get eventEmitter();
 }
-declare const WpEventsTracker: (props?: EventsTrackerProps) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface EntityVersioningProviderProps {
-    disabled?: boolean;
+declare class TrackingService {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    trackEvent<T>(event: IEventLog<T>): Promise<void>;
+    private get tracker();
 }
-declare const WpEntityVersioningProvider: (props?: EntityVersioningProviderProps) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface DiscoveredModule<T = object> {
-    name: string;
-    instance: T;
-    injectType?: Function | Type$1<any>;
-    dependencyType: Type$1<T>;
-}
-interface DiscoveredClass extends DiscoveredModule {
-    parentModule?: DiscoveredModule;
-}
-interface DiscoveredMethod {
-    handler: (...args: any[]) => any;
-    methodName: string;
-    parentClass: DiscoveredClass;
-}
-interface DiscoveredMethodWithMeta<T> {
-    discoveredMethod: DiscoveredMethod;
-    meta: T;
+declare class AuthenticationServicesResolver {
+    private usersService;
+    private rolesService;
+    private permissionsService;
+    private usersRolesService;
+    registerUsersService(usersService: IAuthUserService<any, any, any>): void;
+    registerRoleService(rolesService: IAuthRoleService<any, any>): void;
+    registerPermissionsService(permissionsService: IAuthPermissionService<any>): void;
+    registerUserRolesService(userRolesService: IAuthUserRolesService<any, any, any, any>): void;
+    getUsersService<TUser extends IAuthUser, TUserRegistrationInfo>(): IAuthUserService<TUser, any, TUserRegistrationInfo>;
+    getRoleService<TRole extends IAuthRole, TPermission extends IAuthPermission>(): IAuthRoleService<TRole, TPermission>;
+    getPermissionService<TPermission extends IAuthPermission>(): IAuthPermissionService<TPermission>;
+    getUserRoleService<TUser extends IAuthUser, TRole extends IAuthRole, TPermission extends IAuthPermission, TAuthOrganizationalUnit extends IAuthOrganizationalUnit>(): IAuthUserRolesService<TUser, TRole, TPermission, TAuthOrganizationalUnit>;
 }
-interface DiscoveredClassWithMeta<T> {
-    discoveredClass: DiscoveredClass;
-    meta: T;
+
+declare class JwtProvider {
+    private readonly jwtService;
+    constructor(jwtService: JwtService);
+    sign<T extends object>(payload: T): Promise<string>;
+    parse<T extends object>(token: string): Promise<T>;
+    verify<T extends object>(token: string): Promise<T>;
 }
-type MetaKey = string | number | symbol;
-type Filter<T> = (item: T) => boolean;
-declare class ModulesContainerProvider {
-    private modulesContainer;
-    setModulesContainer(modulesContainer: ModulesContainer): void;
-    getModules(): [string, Module][];
+
+declare class PasswordHashingProvider {
+    private readonly hashing;
+    constructor(hashing: AppHashingService);
+    hashPassword(input: {
+        password: string;
+        userId: string;
+    }): Promise<string>;
+    verifyPassword(input: {
+        password: string;
+        userId: string;
+        hash: string;
+    }): Promise<{
+        isMatching: boolean;
+    }>;
+    private buildUserSalt;
 }
-declare class CustomDiscoveryService {
-    private readonly modulesContainer;
-    private readonly metadataScanner;
-    private discoveredControllers?;
-    private discoveredProviders?;
-    constructor(modulesContainer: ModulesContainerProvider, metadataScanner: MetadataScanner);
-    /**
-     * Discovers all providers in a Nest App that match a filter
-     * @param filter
-     */
-    providers(filter: Filter<DiscoveredClass>): Promise<DiscoveredClass[]>;
-    /**
-     * Discovers all controller methods that either directly have a certain meta key attached to them
-     * or belong to a controller that has the same meta key attached to them
-     * @param metaKey The meta key to scan for
-     * @param metaFilter An optional filter for the contents of the meta object
-     */
-    methodsAndControllerMethodsWithMetaAtKey<T>(metaKey: MetaKey, metaFilter?: Filter<T>): Promise<DiscoveredMethodWithMeta<T>[]>;
-    /**
-     * Discovers all providers in an App that have meta at a specific key and returns the provider(s) and associated meta
-     * @param metaKey The metakey to scan for
-     */
-    providersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
-    providerWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T> | undefined>;
-    /**
-     * Discovers all controllers in a Nest App that match a filter
-     * @param filter
-     */
-    controllers(filter: Filter<DiscoveredClass>): Promise<DiscoveredClass[]>;
-    /**
-     * Discovers all controllers in an App that have meta at a specific key and returns the controller(s) and associated meta
-     * @param metaKey The metakey to scan for
-     */
-    controllersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
-    /**
-     * Discovers all method handlers matching a particular metakey from a Provider or Controller
-     * @param component
-     * @param metaKey
-     */
-    classMethodsWithMetaAtKey<T>(component: DiscoveredClass, metaKey: MetaKey): DiscoveredMethodWithMeta<T>[];
-    /**
-     * Discovers all the methods that exist on providers in a Nest App that contain metadata under a specific key
-     * @param metaKey The metakey to scan for
-     * @param providerFilter A predicate used to limit the providers being scanned. Defaults to all providers in the app module
-     */
-    providerMethodsWithMetaAtKey<T>(metaKey: MetaKey, providerFilter?: Filter<DiscoveredClass>): Promise<DiscoveredMethodWithMeta<T>[]>;
-    /**
-     * Discovers all the methods that exist on controllers in a Nest App that contain metadata under a specific key
-     * @param metaKey The metakey to scan for
-     * @param controllerFilter A predicate used to limit the controllers being scanned. Defaults to all providers in the app module
-     */
-    controllerMethodsWithMetaAtKey<T>(metaKey: MetaKey, controllerFilter?: Filter<DiscoveredClass>): Promise<DiscoveredMethodWithMeta<T>[]>;
-    private toDiscoveredClass;
-    private extractMethodMetaAtKey;
-    private discover;
-    private getModuleEntries;
+
+declare class UserRegistrationHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly emailService;
+    private readonly jwtProvider;
+    private readonly logger;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, emailService: EmailService, jwtProvider: JwtProvider);
+    execute<TUserRegistrationInfo, TContext extends IAuthUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TContext>): Promise<UserRegistrationResult>;
+    private createPasswordHash;
+    private sendRegistrationEmail;
+    private generateEmailVerifyToken;
+    private createUser;
+    private resolveUser;
 }
 
-declare class EntityManagerRegistry {
-    private readonly container;
-    getContainer(): IEntityManagerServiceRoot;
-    registerGlobalServices({ eventEmitter, }: {
-        eventEmitter?: IEventEmitter;
-    }): Promise<void>;
-    registerDiscoveredEntity(app: INestApplicationContext, { adapter, entityName, entity, converter, queryBuilder, repository, authMiddleware, serializer, snapshotService, settings, }: {
-        entityName: string;
-        entity: DiscoveredClassWithMeta<EntityProps>;
-        repository: DiscoveredClassWithMeta<EntityRepositoryProps>;
-        converter: DiscoveredClassWithMeta<EntityConverterProps>;
-        adapter: DiscoveredClassWithMeta<EntityAdapterProps>;
-        queryBuilder: DiscoveredClassWithMeta<EntityQueryBuilderProps>;
-        serializer: DiscoveredClassWithMeta<EntitySerializerProps>;
-        snapshotService?: DiscoveredClassWithMeta<EntitySnapshotServiceProps>;
-        authMiddleware?: DiscoveredClassWithMeta<EntityAuthMiddlewareProps>;
-        settings: EntityManagerSettings;
-    }): Promise<void>;
-    resolveEntityServicesCollection<TEntity>(entityName: string): EntityServiceLocator<TEntity, unknown>;
+declare class UserDisableHandler {
+    private readonly services;
+    constructor(services: AuthenticationServicesResolver);
+    execute(input: UserDisableInput): Promise<void>;
 }
 
-declare abstract class NestEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    protected readonly services: EntityServiceLocator<TEntity, unknown>;
-    private actionsInstance;
-    constructor(entityName: string, registry: EntityManagerRegistry);
-    protected get converter(): IEntityConverter<TEntity, TEntityDto, TEntityListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
-    get manager(): IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+declare class UserEnableHandler {
+    private readonly services;
+    constructor(services: AuthenticationServicesResolver);
+    execute(input: UserEnableInput): Promise<void>;
 }
 
-declare abstract class NestEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    protected readonly services: EntityServiceLocator<TEntity, unknown>;
-    private managerInstance;
-    constructor(entityName: string, registry: EntityManagerRegistry);
-    get manager(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets>;
-    getRepository<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(): TRepository;
+declare class UserLoginHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
+    execute<TUserContext extends IAuthUserContext>(input: UserLoginInput<TUserContext>): Promise<UserLoginResult>;
+    private generateUserJwtToken;
+    private resolveUser;
 }
 
-declare abstract class NestEntitySerializer<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TSheetItem, TContext, TPayload = unknown> extends EntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem, TContext, TPayload> {
-    private readonly registry;
-    constructor(entityName: string, registry: EntityManagerRegistry);
-    protected get manager(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, any, TEntitySearchParameters, TSorting, TCursor, any>;
+declare class UserPasswordChangeHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
+    execute(input: UserPasswordChangeInput): Promise<void>;
 }
 
-declare abstract class NestEntitySnapshotService<TEntity, TEntityId, TEntityRepository, TEntitySnapshot> extends EntitySnapshotService<TEntityId, TEntitySnapshot> {
-    protected readonly services: EntityServiceLocator<TEntity, unknown>;
-    constructor(entityName: string, registry: EntityManagerRegistry);
-    get repository(): TEntityRepository;
+declare class UserPasswordResetCompleteHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
+    execute(input: UserPasswordResetCompleteInput): Promise<void>;
+    private decodeToken;
+    private validateUser;
+    private getUser;
 }
 
-interface IAuthService {
-}
-interface IAuthRole {
-    id: string;
-    uid: string;
-    name: string;
+declare class UserPasswordResetRequestHandler {
+    private readonly services;
+    private readonly emailService;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
+    execute<TUserContext extends IAuthUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<UserPasswordResetRequestResult>;
+    private sendPasswordResetEmail;
+    private generatePasswordResetToken;
+    private resolveUser;
 }
-interface IAuthPermission {
-    id: string;
-    uid: string;
-    name: string;
+
+declare class UserVerifyCompleteHandler {
+    private readonly services;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, jwtProvider: JwtProvider);
+    execute(input: UserVerifyCompleteInput): Promise<void>;
+    private decodeToken;
+    private validateUser;
+    private getUser;
 }
-interface IAuthOrganizationalUnit {
-    id: string;
-    uid: string;
-    name: string;
+
+declare class UserTokenVerifyHandler {
+    private readonly jwtProvider;
+    constructor(jwtProvider: JwtProvider);
+    execute<TUserContext extends IAuthUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
+    private decodeUserJwtToken;
 }
-interface IAuthUserProfile {
-    firstName: string;
-    lastName: string;
+
+declare class UserVerifyRequestHandler {
+    private readonly services;
+    private readonly emailService;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
+    execute<TUserContext extends IAuthUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<UserVerifyRequestResult>;
+    private sendEmailVerifyEmail;
+    private generateEmailVerifyToken;
+    private resolveUser;
 }
-interface IAuthUserTenant {
-    id: string;
-    uid: string;
-    name: string;
+
+declare class UserCreationHandler {
+    private readonly services;
+    private readonly passwordHashingProvider;
+    private readonly logger;
+    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
+    execute<TUserRegistrationInfo, TContext extends IAuthUserContext>(input: UserCreationInput<TUserRegistrationInfo, TContext>): Promise<UserCreationResult>;
+    private createPasswordHash;
+    private createUser;
+    private resolveUser;
 }
-interface IAuthUserOrganization {
-    id: string;
-    uid: string;
-    name: string;
-    tenant: IAuthUserTenant;
+
+declare class UserDeleteHandler {
+    private readonly services;
+    constructor(services: AuthenticationServicesResolver);
+    execute(input: UserDeleteInput): Promise<void>;
 }
-interface IAuthUser {
-    id: string;
-    passwordHash: string;
-    passwordUpdateTimestamp?: Date;
-    temporaryPassword: boolean;
+
+interface UserImpersonateInput<TUserContext extends IAuthUserContext> {
     userName: string;
-    email: string;
-    verified: boolean;
-    verifiedTimestamp?: Date;
-    disabled: boolean;
-    profile: IAuthUserProfile;
-    organization?: IAuthUserOrganization;
-}
-interface IAuthUserContext {
-    organizationUid?: string;
-}
-interface IAuthUserTokenData<TContext extends IAuthUserContext> {
-    userId: string;
-    email: string;
-    context?: TContext;
+    context?: TUserContext;
 }
-interface IAuthUserService<TUser extends IAuthUser, TUserContext extends IAuthUserContext, TUserRegistrationInfo> {
-    getById(id: string): Promise<TUser>;
-    getByEmail(email: string, context?: TUserContext): Promise<TUser>;
-    getByUserName(userName: string, context?: TUserContext): Promise<TUser>;
-    update(id: string, data: Partial<TUser>): Promise<void>;
-    delete(id: string): Promise<void>;
-    create(email: string, userName: string, data: TUserRegistrationInfo, context?: TUserContext): Promise<TUser>;
+interface UserImpersonateResult {
+    token: string;
 }
-interface IAuthRoleService<TRole extends IAuthRole, TPermission extends IAuthPermission> {
-    create(data: Partial<TRole>): Promise<TRole>;
-    update(id: string, data: Partial<TRole>): Promise<void>;
-    ensure(uid: string, data: Partial<Omit<TRole, "uid">>): Promise<TRole>;
-    delete(id: string): Promise<void>;
-    getById(id: string): Promise<TRole | undefined>;
-    getByUid(uid: string): Promise<TRole | undefined>;
-    addPermission(uid: string, permissionUid: string): Promise<void>;
-    removePermission(uid: string, permissionUid: string): Promise<void>;
-    getPermissions(uid: string): Promise<TPermission[]>;
+
+declare class UserImpersonateHandler {
+    private readonly services;
+    private readonly jwtProvider;
+    constructor(services: AuthenticationServicesResolver, jwtProvider: JwtProvider);
+    execute<TUserContext extends IAuthUserContext>(input: UserImpersonateInput<TUserContext>): Promise<UserImpersonateResult>;
+    private generateUserJwtToken;
+    private resolveUser;
 }
-interface IAuthPermissionService<TPermission extends IAuthPermission> {
-    create(data: Partial<TPermission>): Promise<TPermission>;
-    update(id: string, data: Partial<TPermission>): Promise<void>;
-    ensure(uid: string, data: Partial<Omit<TPermission, "uid">>): Promise<TPermission>;
-    delete(id: string): Promise<void>;
-    getById(id: string): Promise<TPermission | undefined>;
-    getByUid(uid: string): Promise<TPermission | undefined>;
+
+declare class AuthenticationService implements IAuthService {
+    private readonly userCreationHandler;
+    private readonly userDisableHandler;
+    private readonly userDeleteHandler;
+    private readonly userEnableHandler;
+    private readonly userImpersonateHandler;
+    private readonly userLoginHandler;
+    private readonly userPasswordChangeHandler;
+    private readonly userPasswordResetFinalizeHandler;
+    private readonly userPasswordResetRequestHandler;
+    private readonly userRegistrationHandler;
+    private readonly userTokenVerifyHandler;
+    private readonly userVerifyRequestHandler;
+    private readonly userVerifyCompleteHandler;
+    private readonly resolver;
+    constructor(userCreationHandler: UserCreationHandler, userDisableHandler: UserDisableHandler, userDeleteHandler: UserDeleteHandler, userEnableHandler: UserEnableHandler, userImpersonateHandler: UserImpersonateHandler, userLoginHandler: UserLoginHandler, userPasswordChangeHandler: UserPasswordChangeHandler, userPasswordResetFinalizeHandler: UserPasswordResetCompleteHandler, userPasswordResetRequestHandler: UserPasswordResetRequestHandler, userRegistrationHandler: UserRegistrationHandler, userTokenVerifyHandler: UserTokenVerifyHandler, userVerifyRequestHandler: UserVerifyRequestHandler, userVerifyCompleteHandler: UserVerifyCompleteHandler, resolver: AuthenticationServicesResolver);
+    userCreate<TUserRegistrationInfo, TUserContext extends IAuthUserContext>(input: UserCreationInput<TUserRegistrationInfo, TUserContext>): Promise<UserCreationResult>;
+    userDisable(input: UserDisableInput): Promise<void>;
+    userDelete(input: UserDeleteInput): Promise<void>;
+    userEnable(input: UserEnableInput): Promise<void>;
+    userImpersonate<TUserContext extends IAuthUserContext>(input: UserImpersonateInput<TUserContext>): Promise<UserImpersonateResult>;
+    userLogin<TUserContext extends IAuthUserContext>(input: UserLoginInput<TUserContext>): Promise<UserLoginResult>;
+    userPasswordChange(input: UserPasswordChangeInput): Promise<void>;
+    userPasswordResetFinalize(input: UserPasswordResetCompleteInput): Promise<void>;
+    userPasswordResetRequest<TUserContext extends IAuthUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<UserPasswordResetRequestResult>;
+    userRegister<TUserRegistrationInfo, TUserContext extends IAuthUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TUserContext>): Promise<UserRegistrationResult>;
+    userVerifyRequest<TUserContext extends IAuthUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<UserVerifyRequestResult>;
+    userVerifyComplete(input: UserVerifyCompleteInput): Promise<void>;
+    userTokenVerify<TUserContext extends IAuthUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
+    get usersService(): IAuthUserService<IAuthUser, any, unknown>;
+    get rolesService(): IAuthRoleService<IAuthRole, IAuthPermission>;
+    get userRolesService(): IAuthUserRolesService<IAuthUser, IAuthRole, IAuthPermission, IAuthOrganizationalUnit>;
 }
-interface IAuthUserRolesService<TUser extends IAuthUser, TRole extends IAuthRole, TPermission extends IAuthPermission, TOrganizationalUnit extends IAuthOrganizationalUnit> {
-    getRoleUsers(roleId: string): Promise<TUser[]>;
-    getUserRoles(userId: string): Promise<TRole[]>;
-    getUserPermissions(userId: string): Promise<TPermission[]>;
-    getUserOrganizationalUnits(userId: string): Promise<TOrganizationalUnit[]>;
-    addUserToRole(userId: string, roleId: string): Promise<void>;
-    addUserToRoleByUid(userId: string, roleUid: string): Promise<void>;
-    removeUserFromRole(userId: string, roleId: string): Promise<void>;
-    removeUserFromRoleByUid(userId: string, roleUid: string): Promise<void>;
-    clearUserRoles(userId: string): Promise<void>;
+
+declare class AuthenticationModule implements NestModule {
+    static forRoot(input: AuthenticationModuleSettings): DynamicModule;
+    configure(consumer: MiddlewareConsumer): void;
 }
 
-type CurrentUserData = {
-    user: IAuthUser;
-    roles: IAuthRole[];
-    permissions: IAuthPermission[];
-    organizationalUnits: IAuthOrganizationalUnit[];
-};
-declare const CurrentUser: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-interface AuthenticationModuleSettings {
-    passwordSalt: string;
-    jwtSecret: string;
+interface IAppDirectory {
+    id: string;
+    uid: string;
+    name: string;
 }
-type UserPasswordResetTokenPayload = {
-    userId: string;
-    email: string;
-    timestamp: number;
-};
-type EmailVerifyTokenPayload = {
-    userId: string;
-    email: string;
-    timestamp: number;
-};
-declare enum UserRegistrationError {
-    UserAlreadyExists = "userAlreadyExists"
+interface IAppTenant {
+    id: string;
+    uid: string;
+    name: string;
 }
-type AppRole = {
+interface IAppOrganization {
+    id: string;
     uid: string;
     name: string;
-};
-type AppPermission = {
+    tenant: IAppTenant;
+}
+interface IAppCompany {
+    id: string;
     uid: string;
     name: string;
-};
-type RolesGuardOptions = {
-    exact?: boolean;
-};
-
-declare const Public: () => _nestjs_common.CustomDecorator<string>;
-declare const Authenticated: () => _nestjs_common.CustomDecorator<string>;
-declare const Permissions: (...permissions: string[]) => _nestjs_common.CustomDecorator<string>;
-declare const Roles: (...roles: string[]) => _nestjs_common.CustomDecorator<string>;
-declare const MemberOf: (...groups: string[]) => _nestjs_common.CustomDecorator<string>;
-declare const buildRolesGuard: ({ mainRole, secondaryRoles, }: {
-    mainRole: AppRole;
-    secondaryRoles?: AppRole[] | undefined;
-}, options?: RolesGuardOptions) => _nestjs_common.CustomDecorator<string>;
-declare const buildPermissionsGuard: ({ permissions, }: {
-    permissions: AppPermission[];
-}) => _nestjs_common.CustomDecorator<string>;
-
-declare const WpPermissionsService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-
-declare const AuthenticationExtensionSymbols: {
-    UserService: symbol;
-    RolesService: symbol;
-    PermissionsService: symbol;
-    UserRolesService: symbol;
-};
-
-declare const WpRolesService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-
-declare const WpUserService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-
-declare const WpUserRolesService: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-
-declare const AuthenticationEmailTemplates: {
-    Registration: string;
-    PasswordReset: string;
-    EmailVerify: string;
-};
-type RegistrationEmailPayload = {
-    firstName: string;
-    lastName: string;
-    callbackUrl: string;
-};
-type EmailVerifyEmailPayload = {
-    firstName: string;
-    lastName: string;
-    callbackUrl: string;
-};
-type PasswordResetEmailPayload = {
+    organization: IAppOrganization;
+}
+interface IAppDivision {
+    id: string;
+    uid: string;
+    name: string;
+    company: IAppCompany;
+}
+interface IAppUserProfile {
     firstName: string;
     lastName: string;
-    callbackUrl: string;
-};
+}
+interface IAppUser {
+    id: string;
+    uid?: string;
+    userName: string;
+    email: string;
+    verified: boolean;
+    disabled: boolean;
+    profile: IAppUserProfile;
+    tenant: IAppTenant;
+    directory: IAppDirectory;
+    organization?: IAppOrganization;
+}
+interface IAppUserGroup {
+    id: string;
+    uid: string;
+    name: string;
+    disabled: boolean;
+    isBuiltIn: boolean;
+    organization?: IAppOrganization;
+}
+interface IAppRole {
+    id: string;
+    uid: string;
+    name: string;
+}
 
-declare class AuthenticationError extends Error {
-    constructor(message: string);
+interface IMultiTenantEntity {
+    tenant: IAppTenant;
 }
-declare class InvalidCredentialsError extends AuthenticationError {
-    constructor(message: string);
+interface IMultiOrganizationEntity {
+    organization: IAppOrganization;
 }
-declare class OperationTokenMismatchError extends AuthenticationError {
-    constructor(message: string);
+interface IMultiCompanyEntity {
+    company: IAppCompany;
 }
 
-declare const AUTHENTICATION_EVENTS_NAMESPACE = "authentication";
-declare const AuthenticationEvents: {
-    UserLogin: string;
-    UserRegistrationStarted: string;
-    UserRegistrationCompleted: string;
-    UserPasswordResetStarted: string;
-    UserPasswordResetCompleted: string;
-};
+declare class MultiTenancyModule {
+}
 
-type UserProfile = {
-    firstName: string;
-    lastName: string;
-};
-type UserLoginEventPayload = {
-    userId: string;
-    email: string;
-    profile: UserProfile;
-};
-type UserRegistrationStartedEventPayload = {
-    email: string;
-    profile: UserProfile;
-};
-type UserRegistrationCompletedEventPayload = {
-    userId: string;
-    email: string;
-    profile: UserProfile;
-};
-type UserPasswordResetStartedEventPayload = {
-    email: string;
-};
-type UserPasswordResetCompletedEventPayload = {
-    userId: string;
-    email: string;
-    profile: UserProfile;
-};
+declare const createExpressFileResponse: (res: Response, file: {
+    content: Buffer;
+    contentType: string;
+    name: string;
+}) => StreamableFile;
 
-declare class AuthGuard implements CanActivate {
-    private reflector;
-    private readonly logger;
-    constructor(reflector: Reflector);
-    canActivate(context: ExecutionContext): boolean;
-    private isRoleMatching;
-    private isPermissionMatching;
-    private getIsForAllAuthenticated;
-    private getIsPublic;
-    private getAllowedRoles;
-    private getAllowedPermissions;
-    private getCurrentAuth;
-    private getMetadata;
-    private getContextInfo;
+interface ICacheDatabaseItem {
+    id: string;
+    instance: string;
+    key: string;
+    data: any;
+    createdOn: Date;
+    updatedOn: Date;
+    expirationTime: Date;
 }
 
-declare enum UserCreationError {
-    UserAlreadyExists = "userAlreadyExists"
-}
-interface UserCreationInput<TUserRegistrationInfo, TUserContext extends IAuthUserContext> {
-    email: string;
-    userName: string;
-    password: string;
-    registrationInfo: TUserRegistrationInfo;
-    context?: TUserContext;
-}
-interface UserCreationResult {
-    success: boolean;
-    error?: UserCreationError;
-    userId?: string;
+declare abstract class TypeormCacheInstance<TEntity extends ICacheDatabaseItem> implements ICacheInstance {
+    protected readonly instanceName: string;
+    private readonly logger;
+    constructor(instanceName: string);
+    getInstanceName(): string;
+    getEntries(): Promise<CacheEntryInfo[]>;
+    getEntry(key: string): Promise<CacheEntryDetail | undefined>;
+    retrieve<T>(key: string, input: {
+        ttl: CacheTtl;
+        valueFactory: () => Promise<T>;
+    }): Promise<T>;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, { ttl, value }: {
+        value: T;
+        ttl: CacheTtl;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    protected abstract getRepository(): Repository<TEntity>;
 }
 
-interface UserDisableInput {
-    userId: string;
+declare class PipelineController implements IPipelinesController {
+    createInstance<TInput, TOutput, TContext>(definition: PipelineDefinition<TInput, TOutput, TContext>, input: TInput, context: TContext): Promise<IPipelineInstance<TInput, TOutput, TContext>>;
 }
 
-interface UserDeleteInput {
-    userId: string;
+declare enum QueryBuilderOperation {
+    Search = "search",
+    Get = "get"
 }
-
-interface UserEnableInput {
-    userId: string;
+declare abstract class QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext> {
+    abstract get(id: TEntityId, context?: IAuthenticationContext<TUserContext> | undefined): Promise<TEntity | undefined>;
+    abstract exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
+    abstract count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
+    abstract delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;
+    abstract search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+    abstract find(request: {
+        filters?: TEntitySearchParameters["filters"];
+        sorting?: TEntitySearchParameters["sorting"];
+    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
+    protected getIndexBasedPagingResult({ paging, totResults, currentPageResults, }: {
+        paging?: ISearchRequestPaging<number>;
+        totResults: number;
+        currentPageResults: number;
+    }): IEntitiesSearchResultsPaging<number> | undefined;
 }
 
-interface UserLoginInput<TUserContext extends IAuthUserContext> {
-    userName: string;
-    password: string;
-    context?: TUserContext;
-}
-interface UserLoginResult {
-    token?: string;
-    success: boolean;
+type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
+type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
+declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
+    protected readonly innerRepository: Repository<TEntity>;
+    private readonly logger;
+    constructor(innerRepository: Repository<TEntity>);
+    getInnerRepository(): Repository<TEntity>;
+    distinct<TField extends keyof TEntity, TValue>(field: TField, condition: FindManyOptions<TEntity>): Promise<any[]>;
+    exists(id: TEntityId): Promise<boolean>;
+    existsBy(condition: FindOneOptions<TEntity>): Promise<boolean>;
+    get(id: TEntityId, options?: {
+        relations?: FindOptionsRelations<TEntity>;
+    }): Promise<TEntity | undefined>;
+    getBy(condition: FindOneOptions<TEntity>): Promise<TEntity | undefined>;
+    all(): Promise<TEntity[]>;
+    count(condition: FindManyOptions<TEntity>): Promise<number>;
+    find(condition: FindManyOptions<TEntity>): Promise<TEntity[]>;
+    findById(id: TEntityId[]): Promise<TEntity[]>;
+    delete(id: TEntityId): Promise<void>;
+    deleteBy(condition: DeleteCriteria<TEntity>): Promise<IEntitiesDeleteResult>;
+    create(entity: Partial<TEntity>): Promise<TEntity>;
+    update(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+    updateBy(entity: Partial<TEntity>, condition: UpdateCriteria<TEntity>): Promise<TEntity[]>;
+    upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
 }
 
-interface UserPasswordChangeInput {
-    userId: string;
-    newPassword: string;
-    temporary: boolean;
-}
+type NumericFilter = {
+    in?: number[];
+    eq?: number;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+};
+type StringFilter = {
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    in?: string[];
+    eq?: string;
+    like?: string;
+    ne?: string;
+    notIn?: string[];
+    notLike?: string;
+};
+type EnumFilter<T> = {
+    in?: T[];
+    eq?: T;
+    ne?: T;
+    notIn?: T[];
+};
+type BooleanFilter = {
+    eq?: boolean;
+    ne?: boolean;
+};
+type DateFilter = {
+    in?: Date[];
+    eq?: Date;
+    gt?: Date;
+    gte?: Date;
+    lt?: Date;
+    lte?: Date;
+};
 
-interface UserPasswordResetCompleteInput {
-    token: string;
-    newPassword: string;
-    temporary?: boolean;
+declare class QueryClauseBuilder {
+    enumFilter<T>(filter: EnumFilter<T>): FindOperator<T>;
+    stringFilter(filter: StringFilter): FindOperator<string>;
+    numericFilter(filter: NumericFilter): FindOperator<number>;
+    dateFilter(filter: DateFilter): FindOperator<Date>;
+    boolFilter(filter: BooleanFilter): FindOperator<boolean>;
 }
 
-type UserPasswordResetRequestCallbackTemplate = {
-    urlTemplate: string;
-    tokenPlaceholder: string;
+type FacetValueType<T> = {
+    value: T;
+    count: number;
 };
-interface UserPasswordResetRequestInput<TUserContext extends IAuthUserContext> {
-    email: string;
-    callback: UserPasswordResetRequestCallbackTemplate;
-    languageCode: string;
-    context?: TUserContext;
-}
-interface UserPasswordResetRequestResult {
-    success: boolean;
-}
+type FacetType<T> = {
+    values: FacetValueType<T>[];
+};
+type StringFacetsType = FacetType<string>;
+type NumberFacetsType = FacetType<number>;
+type BooleanFacetsType = FacetType<boolean>;
 
-type UserRegisterCallbackTemplate = {
-    urlTemplate: string;
-    tokenPlaceholder: string;
+type ChildrenMap = Record<string, {
+    count: number;
+}>;
+
+type FacetRelations = {
+    columns: string[];
 };
-interface UserRegistrationInput<TUserRegistrationInfo, TUserContext extends IAuthUserContext> {
-    email: string;
-    userName: string;
-    password: string;
-    registrationInfo: TUserRegistrationInfo;
-    callback: UserRegisterCallbackTemplate;
-    languageCode: string;
-    context?: TUserContext;
-}
-interface UserRegistrationResult {
-    success: boolean;
-    error?: UserRegistrationError;
-    userId?: string;
+declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
+    private readonly services;
+    private repository;
+    protected clause: QueryClauseBuilder;
+    protected permissions: PermissionsChecker<TUserContext>;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
+    exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
+    count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
+    delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;
+    find(request: {
+        filters?: TEntitySearchParameters["filters"];
+        sorting?: TEntitySearchParameters["sorting"];
+    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
+    search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, number, TFacets>>;
+    protected getFieldDistinctValues<T>(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<T[]>;
+    protected findPagedQueryResults(request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<TEntity[]>;
+    protected getRelationsToLoad(request: TEntitySearchParameters | undefined, context: IAuthenticationContext<TUserContext> | undefined, operation: QueryBuilderOperation): FindOptionsRelations<TEntity> | undefined;
+    protected buildPagingParameters(request: TEntitySearchParameters): {
+        skip: number | undefined;
+        take: number | undefined;
+    };
+    protected countQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<number>;
+    protected abstract buildSortingClause(request: TEntitySearchParameters): FindOptionsOrder<TEntity>;
+    protected abstract buildWhereClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
+    protected buildTextSearchClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
+    protected abstract buildContextFilter(context?: IAuthenticationContext<TUserContext>): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
+    protected abstract calculateFacets(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TFacets>;
+    protected calculateChildrenMap(items: TEntity[]): Promise<ChildrenMap>;
+    protected queryChildrenMap<TField extends keyof TEntity>({ nodeIds, idField, parentField, }: {
+        nodeIds: string[];
+        idField: TField;
+        parentField: TField;
+    }): Promise<ChildrenMap>;
+    protected calculateFacet<TField extends keyof TEntity, TValue>(field: TField, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<FacetType<TValue>>;
+    protected calculateStringFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<StringFacetsType>;
+    protected calculateNumericFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<NumberFacetsType>;
+    protected calculateBooleanFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<BooleanFacetsType>;
+    protected getRepository(): TypeOrmRepository<TEntity, unknown>;
+    private buildSearchRelations;
+    private buildWhere;
+    private mergeWhereClauses;
+    private mergeWheres;
 }
 
-interface UserTokenVerifyResult<TUserContext extends IAuthUserContext> {
-    isValid: boolean;
-    data: IAuthUserTokenData<TUserContext>;
-}
-interface UserTokenVerifyInput {
-    token: string;
+declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends TypeOrmQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TFacets, TUserContext> {
+    constructor(entityName: string, registry: EntityManagerRegistry);
 }
 
-interface UserVerifyCompleteInput {
-    token: string;
+declare class NestTypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> extends TypeOrmRepository<TEntity, TEntityId> {
+    constructor(repository: Repository<TEntity>);
 }
 
-interface UserVerifyRequestInput<TUserContext extends IAuthUserContext> {
-    email: string;
-    callback: UserVerifyRequestCallbackTemplate;
-    languageCode: string;
-    context?: TUserContext;
+interface IEntitySeedEntry<TEntity, TFindCondition> {
+    identifier: TFindCondition;
+    data: () => Partial<TEntity>;
 }
-interface UserVerifyRequestResult {
-    success: boolean;
+interface IEntitySeeder {
+    execute(): Promise<void>;
+    get priority(): number | undefined;
 }
-type UserVerifyRequestCallbackTemplate = {
-    urlTemplate: string;
-    tokenPlaceholder: string;
-};
 
-declare class AppSessionService {
-    getValue<T>(key: string): T;
-    setValue<T>(key: string, value: T): void;
-    clearValue(key: string): void;
-    getRequest(): express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
-    retrieveRequest(): express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>> | undefined;
-    private retrieveSession;
-    private getSession;
+declare abstract class EntitySeeder<TEntity, TFindCondition> implements IEntitySeeder {
+    protected readonly logger: _punks_backend_core.ILogger;
+    execute(): Promise<void>;
+    protected abstract getEntries(): Promise<IEntitySeedEntry<TEntity, TFindCondition>[]>;
+    protected abstract exists(condition: TFindCondition): Promise<boolean>;
+    protected abstract create(entity: Partial<TEntity>): Promise<void>;
+    abstract get priority(): number | undefined;
 }
 
-declare class AppHashingService {
-    hash(value: string, salt: string): Promise<string>;
-    compare(hash: string, value: string, salt: string): Promise<boolean>;
+declare abstract class TypeOrmEntitySeeder<TEntity extends ObjectLiteral> extends EntitySeeder<TEntity, FindOneOptions<TEntity>> {
+    protected exists(condition: FindOneOptions<TEntity>): Promise<boolean>;
+    protected create(entity: TEntity): Promise<void>;
+    protected abstract getRepository(): Repository<TEntity>;
 }
 
-declare class EntityManagerService {
+declare abstract class NestTypeOrmEntitySeeder<TEntity extends ObjectLiteral> extends TypeOrmEntitySeeder<TEntity> {
     private readonly registry;
+    protected readonly metadata: EntitySeederProps;
     constructor(registry: EntityManagerRegistry);
-    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
-    getActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
-    getRepository<TEntity>(entityName: string): IEntityRepository<TEntity, unknown, unknown, unknown, unknown, unknown>;
+    get priority(): number | undefined;
+    protected getRepository(): Repository<TEntity>;
 }
 
-declare class EmailService {
-    private readonly registry;
-    constructor(registry: EntityManagerRegistry);
-    sendTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
-    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
-    private getTemplate;
-    private get templates();
-    private get provider();
-    private get logger();
+interface RuntimeErrorInformation {
+    exception: any;
+    request: any;
+    response: any;
+}
+declare abstract class AppExceptionsFilterBase implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): void;
+    protected getExceptionType(exception: any): any;
+    protected getExceptionStack(exception: any): any;
+    protected getExceptionMessage(exception: any): any;
+    protected getErrorStatusCode(exception: any): number;
+    protected abstract logError(info: RuntimeErrorInformation): Promise<void>;
+    protected abstract getCustomErrorStatusCode(exception: any): number | undefined;
 }
 
-declare class CacheService {
-    private readonly registry;
-    constructor(registry: EntityManagerRegistry);
-    getInstance(instanceName: string): ICacheInstance;
-    getInstances(): ICacheInstance[];
+interface IPipelineStepOperationOptionsBuilder<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> {
+    withRollback(definition: RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>): IPipelineStepOperationOptionsBuilder<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>;
 }
-
-declare class FilesService implements IFileManager {
-    private readonly registry;
-    constructor(registry: EntityManagerRegistry);
-    uploadFile(file: FileData): Promise<FileReference>;
-    getFileContent(fileId: string): Promise<FileData>;
-    getFileDownloadUrl(fileId: string): Promise<FileDownloadUrl>;
-    private getFileProvider;
-    private get defaultFileProvider();
-    private get referencesRepo();
+interface IPipelineStepOperationBuilder<TStepInput, TStepOutput, TPipelineInput, TContext> {
+    addOperation(operation: OperationDefinition<TStepInput, TStepOutput, TStepInput, TPipelineInput, TContext>): IPipelineStepOperationOptionsBuilder<TStepInput, TStepOutput, TStepInput, TPipelineInput, TContext>;
+}
+interface IPipelineStepBuilder<TStepInput, TStepOutput, TPipelineInput, TContext> {
+    addStep<TNextStepOutput>(builder: (step: IPipelineStepOperationBuilder<TStepOutput, TNextStepOutput, TPipelineInput, TContext>) => void): IPipelineStepBuilder<TStepOutput, TNextStepOutput, TPipelineInput, TContext>;
+    complete(): PipelineDefinition<TPipelineInput, TStepOutput, TContext>;
+}
+interface IPipelineTemplateBuilder<TPipelineInput, TContext> {
+    addStep<TStepOutput>(builder: (step: IPipelineStepOperationBuilder<TPipelineInput, TStepOutput, TPipelineInput, TContext>) => void): IPipelineStepBuilder<TPipelineInput, TStepOutput, TPipelineInput, TContext>;
 }
 
-type IEventData<TEventPayload> = {
-    payload?: TEventPayload;
-    userId?: string;
-    userName?: string;
-    timestamp?: Date;
-};
-declare class EventsService {
+declare class PipelinesBuilder {
     private readonly registry;
     constructor(registry: EntityManagerRegistry);
-    emitEvent<TEventPayload>(eventName: string, eventData: IEventData<TEventPayload>): Promise<void>;
-    private buildPayload;
-    private get eventEmitter();
+    createTemplate<TInput, TContext>(): IPipelineTemplateBuilder<TInput, TContext>;
 }
 
-declare class TrackingService {
+declare class PipelinesRunner {
     private readonly registry;
     constructor(registry: EntityManagerRegistry);
-    trackEvent<T>(event: IEventLog<T>): Promise<void>;
-    private get tracker();
+    invokePipeline<TPipelineInput, TPipelineOutput, TContext>(definition: PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>, data: {
+        input: TPipelineInput;
+        context: TContext;
+    }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
+    private get controller();
 }
 
-declare class AuthenticationServicesResolver {
-    private usersService;
-    private rolesService;
-    private permissionsService;
-    private usersRolesService;
-    registerUsersService(usersService: IAuthUserService<any, any, any>): void;
-    registerRoleService(rolesService: IAuthRoleService<any, any>): void;
-    registerPermissionsService(permissionsService: IAuthPermissionService<any>): void;
-    registerUserRolesService(userRolesService: IAuthUserRolesService<any, any, any, any>): void;
-    getUsersService<TUser extends IAuthUser, TUserRegistrationInfo>(): IAuthUserService<TUser, any, TUserRegistrationInfo>;
-    getRoleService<TRole extends IAuthRole, TPermission extends IAuthPermission>(): IAuthRoleService<TRole, TPermission>;
-    getPermissionService<TPermission extends IAuthPermission>(): IAuthPermissionService<TPermission>;
-    getUserRoleService<TUser extends IAuthUser, TRole extends IAuthRole, TPermission extends IAuthPermission, TAuthOrganizationalUnit extends IAuthOrganizationalUnit>(): IAuthUserRolesService<TUser, TRole, TPermission, TAuthOrganizationalUnit>;
+declare class PipelineUtils<TPipelineInput, TPipelineOutput, TContext> {
+    getStep: (step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
+    getStepInput: <TStepInput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepInput;
+    getStepOutput: <TStepOutput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepOutput;
 }
 
-declare class JwtProvider {
-    private readonly jwtService;
-    constructor(jwtService: JwtService);
-    sign<T extends object>(payload: T): Promise<string>;
-    parse<T extends object>(token: string): Promise<T>;
-    verify<T extends object>(token: string): Promise<T>;
+declare abstract class NestPipelineTemplate<TPipelineInput, TPipelineOutput, TContext> {
+    protected readonly logger: _punks_backend_core.ILogger;
+    protected readonly utils: PipelineUtils<TPipelineInput, TPipelineOutput, TContext>;
+    private cachedDefinition;
+    protected abstract buildTemplate(builder: IPipelineTemplateBuilder<TPipelineInput, TContext>): PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>;
+    protected isAuthorized(context: TContext): boolean;
+    invoke(input: TPipelineInput): Promise<TPipelineOutput>;
+    execute(data: {
+        input: TPipelineInput;
+        context: TContext;
+    }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
+    private getDefinition;
+    private buildDefinition;
+    private getContext;
+    private get controller();
+    private get registry();
+    protected get metadata(): PipelineTemplateProps;
 }
 
-declare class PasswordHashingProvider {
-    private readonly hashing;
-    constructor(hashing: AppHashingService);
-    hashPassword(input: {
-        password: string;
-        userId: string;
-    }): Promise<string>;
-    verifyPassword(input: {
-        password: string;
-        userId: string;
-        hash: string;
-    }): Promise<{
-        isMatching: boolean;
-    }>;
-    private buildUserSalt;
+declare class PipelineInvocationError extends Error {
+    readonly errorType: PipelineErrorType;
+    readonly innerError: Error | undefined;
+    readonly rawResult: PipelineResult<unknown, unknown>;
+    constructor(errorType: PipelineErrorType, innerError: Error | undefined, rawResult: PipelineResult<unknown, unknown>, message?: string);
 }
 
-declare class UserRegistrationHandler {
-    private readonly services;
-    private readonly passwordHashingProvider;
-    private readonly emailService;
-    private readonly jwtProvider;
-    private readonly logger;
-    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, emailService: EmailService, jwtProvider: JwtProvider);
-    execute<TUserRegistrationInfo, TContext extends IAuthUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TContext>): Promise<UserRegistrationResult>;
-    private createPasswordHash;
-    private sendRegistrationEmail;
-    private generateEmailVerifyToken;
-    private createUser;
-    private resolveUser;
+declare class AwsS3BucketError extends Error {
+    constructor(message: string);
 }
 
-declare class UserDisableHandler {
-    private readonly services;
-    constructor(services: AuthenticationServicesResolver);
-    execute(input: UserDisableInput): Promise<void>;
+declare class AppInMemorySettings<T> {
+    private _instance;
+    constructor();
+    initialize(value: T): void;
+    get value(): T;
 }
 
-declare class UserEnableHandler {
-    private readonly services;
-    constructor(services: AuthenticationServicesResolver);
-    execute(input: UserEnableInput): Promise<void>;
-}
+type AwsBucketPaths = {
+    filesUpload: string;
+};
+type AwsBucketSettings = {
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+    region?: string;
+    defaultBucket: string;
+    publicLinksExpirationMinutes: number;
+    paths: AwsBucketPaths;
+};
 
-declare class UserLoginHandler {
-    private readonly services;
-    private readonly passwordHashingProvider;
-    private readonly jwtProvider;
-    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
-    execute<TUserContext extends IAuthUserContext>(input: UserLoginInput<TUserContext>): Promise<UserLoginResult>;
-    private generateUserJwtToken;
-    private resolveUser;
+declare class AwsBucketModule {
+    static forRoot(input: AwsBucketSettings): DynamicModule;
 }
 
-declare class UserPasswordChangeHandler {
-    private readonly services;
-    private readonly passwordHashingProvider;
-    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
-    execute(input: UserPasswordChangeInput): Promise<void>;
+type BucketFolderListInput = {
+    bucket: string;
+    maxResults?: number;
+    path?: string;
+};
+declare enum BucketItemType {
+    File = "file",
+    Folder = "folder"
 }
-
-declare class UserPasswordResetCompleteHandler {
-    private readonly services;
-    private readonly passwordHashingProvider;
-    private readonly jwtProvider;
-    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
-    execute(input: UserPasswordResetCompleteInput): Promise<void>;
-    private decodeToken;
-    private validateUser;
-    private getUser;
+type BucketContentItem = {
+    type: BucketItemType;
+    name: string;
+    path: string;
+};
+type BucketFolderContentResult = {
+    items: BucketContentItem[];
+};
+type BucketFolderListResult = {};
+type BucketFolderCreateInput = {
+    bucket: string;
+    path: string;
+};
+type BucketFolderEnsureInput = {
+    bucket: string;
+    path: string;
+};
+type BucketFolderExistsInput = {
+    bucket: string;
+    path: string;
+};
+type BucketFileDownloadInput = {
+    bucket: string;
+    filePath: string;
+};
+type BucketFilePublicUrlCreateInput = {
+    bucket: string;
+    filePath: string;
+    expirationMinutes: number;
+};
+type BucketFileUploadInput = {
+    bucket: string;
+    filePath: string;
+    content: Buffer;
+    contentType?: string;
+};
+interface BucketFileDeleteInput {
+    bucket: string;
+    filePath: string;
 }
-
-declare class UserPasswordResetRequestHandler {
-    private readonly services;
-    private readonly emailService;
-    private readonly jwtProvider;
-    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
-    execute<TUserContext extends IAuthUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<UserPasswordResetRequestResult>;
-    private sendPasswordResetEmail;
-    private generatePasswordResetToken;
-    private resolveUser;
+interface IBucketProvider {
+    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
+    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
+    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
+    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
+    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
+    fileUpload(input: BucketFileUploadInput): Promise<void>;
+    fileDelete(input: BucketFileDeleteInput): Promise<void>;
 }
 
-declare class UserVerifyCompleteHandler {
-    private readonly services;
-    private readonly jwtProvider;
-    constructor(services: AuthenticationServicesResolver, jwtProvider: JwtProvider);
-    execute(input: UserVerifyCompleteInput): Promise<void>;
-    private decodeToken;
-    private validateUser;
-    private getUser;
+declare class AwsS3BucketProvider implements IBucketProvider {
+    private readonly client;
+    constructor();
+    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
+    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
+    folderCreate(input: BucketFolderEnsureInput): Promise<void>;
+    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
+    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
+    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
+    fileUpload(input: BucketFileUploadInput): Promise<void>;
+    fileDelete(input: BucketFileDeleteInput): Promise<void>;
 }
 
-declare class UserTokenVerifyHandler {
-    private readonly jwtProvider;
-    constructor(jwtProvider: JwtProvider);
-    execute<TUserContext extends IAuthUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
-    private decodeUserJwtToken;
+declare class InMemoryBucketProvider implements IBucketProvider {
+    private inMemoryStorage;
+    private inMemoryFolders;
+    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
+    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
+    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
+    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
+    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
+    fileUpload(input: BucketFileUploadInput): Promise<void>;
+    fileDelete(input: BucketFileDeleteInput): Promise<void>;
 }
 
-declare class UserVerifyRequestHandler {
-    private readonly services;
-    private readonly emailService;
-    private readonly jwtProvider;
-    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
-    execute<TUserContext extends IAuthUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<UserVerifyRequestResult>;
-    private sendEmailVerifyEmail;
-    private generateEmailVerifyToken;
-    private resolveUser;
-}
+type AwsSesEmailTemplateData = {
+    subjectTemplate: string;
+    htmlTemplate: string;
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    replyTo?: string;
+};
 
-declare class UserCreationHandler {
-    private readonly services;
-    private readonly passwordHashingProvider;
-    private readonly logger;
-    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
-    execute<TUserRegistrationInfo, TContext extends IAuthUserContext>(input: UserCreationInput<TUserRegistrationInfo, TContext>): Promise<UserCreationResult>;
-    private createPasswordHash;
-    private createUser;
-    private resolveUser;
+declare abstract class AwsSesEmailTemplate<TPayload, TAugmentedPayload = TPayload> implements IEmailTemplate<AwsSesEmailTemplateData, TPayload, TAugmentedPayload> {
+    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
+    getTemplateData(payload: TAugmentedPayload): Promise<AwsSesEmailTemplateData>;
 }
 
-declare class UserDeleteHandler {
-    private readonly services;
-    constructor(services: AuthenticationServicesResolver);
-    execute(input: UserDeleteInput): Promise<void>;
-}
+declare const WpAwsSesEmailTemplate: (templateId: string, sendgridTemplateData: AwsSesEmailTemplateData) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
 
-interface UserImpersonateInput<TUserContext extends IAuthUserContext> {
-    userName: string;
-    context?: TUserContext;
-}
-interface UserImpersonateResult {
-    token: string;
-}
+type AwsSesSettings = {
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+    region?: string;
+    defaultSender: string;
+    defaultCc?: string[];
+    defaultBcc?: string[];
+};
 
-declare class UserImpersonateHandler {
-    private readonly services;
-    private readonly jwtProvider;
-    constructor(services: AuthenticationServicesResolver, jwtProvider: JwtProvider);
-    execute<TUserContext extends IAuthUserContext>(input: UserImpersonateInput<TUserContext>): Promise<UserImpersonateResult>;
-    private generateUserJwtToken;
-    private resolveUser;
+declare class AwsEmailModule {
+    static forRoot(input: AwsSesSettings): DynamicModule;
 }
 
-declare class AuthenticationService implements IAuthService {
-    private readonly userCreationHandler;
-    private readonly userDisableHandler;
-    private readonly userDeleteHandler;
-    private readonly userEnableHandler;
-    private readonly userImpersonateHandler;
-    private readonly userLoginHandler;
-    private readonly userPasswordChangeHandler;
-    private readonly userPasswordResetFinalizeHandler;
-    private readonly userPasswordResetRequestHandler;
-    private readonly userRegistrationHandler;
-    private readonly userTokenVerifyHandler;
-    private readonly userVerifyRequestHandler;
-    private readonly userVerifyCompleteHandler;
-    private readonly resolver;
-    constructor(userCreationHandler: UserCreationHandler, userDisableHandler: UserDisableHandler, userDeleteHandler: UserDeleteHandler, userEnableHandler: UserEnableHandler, userImpersonateHandler: UserImpersonateHandler, userLoginHandler: UserLoginHandler, userPasswordChangeHandler: UserPasswordChangeHandler, userPasswordResetFinalizeHandler: UserPasswordResetCompleteHandler, userPasswordResetRequestHandler: UserPasswordResetRequestHandler, userRegistrationHandler: UserRegistrationHandler, userTokenVerifyHandler: UserTokenVerifyHandler, userVerifyRequestHandler: UserVerifyRequestHandler, userVerifyCompleteHandler: UserVerifyCompleteHandler, resolver: AuthenticationServicesResolver);
-    userCreate<TUserRegistrationInfo, TUserContext extends IAuthUserContext>(input: UserCreationInput<TUserRegistrationInfo, TUserContext>): Promise<UserCreationResult>;
-    userDisable(input: UserDisableInput): Promise<void>;
-    userDelete(input: UserDeleteInput): Promise<void>;
-    userEnable(input: UserEnableInput): Promise<void>;
-    userImpersonate<TUserContext extends IAuthUserContext>(input: UserImpersonateInput<TUserContext>): Promise<UserImpersonateResult>;
-    userLogin<TUserContext extends IAuthUserContext>(input: UserLoginInput<TUserContext>): Promise<UserLoginResult>;
-    userPasswordChange(input: UserPasswordChangeInput): Promise<void>;
-    userPasswordResetFinalize(input: UserPasswordResetCompleteInput): Promise<void>;
-    userPasswordResetRequest<TUserContext extends IAuthUserContext>(input: UserPasswordResetRequestInput<TUserContext>): Promise<UserPasswordResetRequestResult>;
-    userRegister<TUserRegistrationInfo, TUserContext extends IAuthUserContext>(input: UserRegistrationInput<TUserRegistrationInfo, TUserContext>): Promise<UserRegistrationResult>;
-    userVerifyRequest<TUserContext extends IAuthUserContext>(input: UserVerifyRequestInput<TUserContext>): Promise<UserVerifyRequestResult>;
-    userVerifyComplete(input: UserVerifyCompleteInput): Promise<void>;
-    userTokenVerify<TUserContext extends IAuthUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
-    get usersService(): IAuthUserService<IAuthUser, any, unknown>;
-    get rolesService(): IAuthRoleService<IAuthRole, IAuthPermission>;
-    get userRolesService(): IAuthUserRolesService<IAuthUser, IAuthRole, IAuthPermission, IAuthOrganizationalUnit>;
+type SendgridTemplateType = "template" | "html";
+type SendgridTemplateBaseData = {
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    replyTo?: string;
+};
+type SendgridEmailTemplateData = SendgridTemplateBaseData & ({
+    type: "template";
+    sendgridTemplateId: string;
+} | {
+    type: "html";
+    subjectTemplate: string | LocalizedTexts;
+    bodyTemplate: string | LocalizedTexts;
+});
+
+declare abstract class SendgridEmailTemplate<TPayload, TAugmentedPayload = TPayload> implements IEmailTemplate<SendgridEmailTemplateData, TPayload, TAugmentedPayload> {
+    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
+    getTemplateData(payload: TAugmentedPayload): Promise<SendgridEmailTemplateData>;
 }
 
-declare class AuthenticationModule implements NestModule {
-    static forRoot(input: AuthenticationModuleSettings): DynamicModule;
-    configure(consumer: MiddlewareConsumer): void;
+declare const WpSendgridEmailTemplate: (templateId: string, sendgridTemplateData: SendgridEmailTemplateData) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+type SendgridSettings = {
+    apiKey: string;
+    defaultSender: string;
+    defaultReplyTo?: string;
+    defaultCc?: string[];
+    defaultBcc?: string[];
+    loggingEnabled?: boolean;
+};
+
+declare class SendgridEmailModule {
+    static forRoot(input: SendgridSettings): DynamicModule;
 }
 
-interface IAppDirectory {
-    id: string;
-    uid: string;
-    name: string;
+type SentEmail = {
+    input: TemplatedEmailInput<unknown>;
+    template: IEmailTemplate<void, unknown, unknown>;
+    type: "templated";
+} | {
+    input: HtmlEmailInput<unknown>;
+    type: "html";
+};
+declare class InMemoryEmailProvider implements IEmailProvider<void> {
+    private readonly sentEmails;
+    sendTemplatedEmail<TPayload, TAugmentedPayload>(input: TemplatedEmailInput<TPayload>, template: IEmailTemplate<void, TPayload, TAugmentedPayload>): Promise<void>;
+    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
+    getSentEmails(): SentEmail[];
 }
-interface IAppTenant {
-    id: string;
-    uid: string;
-    name: string;
+
+declare class NestEventEmitter implements IEventEmitter {
+    private eventEmitter;
+    constructor(eventEmitter: EventEmitter2);
+    emit(event: string, ...args: any[]): Promise<void>;
 }
-interface IAppOrganization {
-    id: string;
-    uid: string;
-    name: string;
-    tenant: IAppTenant;
+
+interface EntityManagerStaticProviders {
+    modulesContainer: ModulesContainer$1;
+    authenticationProvider?: IAuthenticationContextProvider<unknown>;
+    settings: EntityManagerSettings;
 }
-interface IAppCompany {
-    id: string;
-    uid: string;
-    name: string;
-    organization: IAppOrganization;
+declare class EntityManagerInitializer {
+    private readonly discover;
+    private readonly registry;
+    private readonly eventEmitter;
+    private readonly logger;
+    constructor(discover: CustomDiscoveryService, registry: EntityManagerRegistry, eventEmitter: NestEventEmitter);
+    initialize(app: INestApplicationContext, staticProviders: EntityManagerStaticProviders): Promise<void>;
+    private registerAuthentication;
+    private registerEntities;
+    private executeInitializers;
+    private executeSeeders;
+    private registerFileProviders;
+    private registerGlobalAuthenticationMiddlewares;
+    private registerBucketProviders;
+    private registerCacheInstances;
+    private registerFilesReferenceRepositoryProviders;
+    private registerEventTrackingProviders;
+    private registerEmailLogger;
+    private registerVersioningProviders;
+    private registerEmailProviders;
+    private registerEmailTemplates;
+    private registerPipelinesServices;
+    private initializeProviders;
+    private discoverEntities;
+    private discoverRepositories;
+    private discoverVersioningProviders;
+    private discoverQueryBuilders;
+    private discoverConverters;
+    private discoverSerializers;
+    private discoverSnapshotService;
+    private discoverAdapters;
+    private discoverAuthMiddlewares;
+    private discoverGlobalAuthenticationMiddlewares;
+    private discoverAppInitializers;
+    private discoverEntitySeeders;
+    private discoverEmailTemplates;
+    private discoverEmailProviders;
+    private discoverEventTrackingProviders;
+    private discoverEmailLogger;
+    private discoverBucketProviders;
+    private discoverCacheInstances;
+    private discoverFileProviders;
+    private discoverFilesReferenceRepositoryProviders;
 }
-interface IAppDivision {
-    id: string;
-    uid: string;
-    name: string;
-    company: IAppCompany;
+
+declare class AppSessionMiddleware implements NestMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void;
 }
-interface IAppUserProfile {
-    firstName: string;
-    lastName: string;
+
+declare class EntityManagerModule implements OnModuleInit {
+    private readonly registry;
+    constructor(registry: EntityManagerRegistry);
+    onModuleInit(): void;
 }
-interface IAppUser {
-    id: string;
-    uid?: string;
-    userName: string;
-    email: string;
-    verified: boolean;
-    disabled: boolean;
-    profile: IAppUserProfile;
-    tenant: IAppTenant;
-    directory: IAppDirectory;
-    organization?: IAppOrganization;
+
+interface IAuthenticationUserRole {
+    uid: string;
 }
-interface IAppUserGroup {
-    id: string;
+interface IAuthenticationUserPermission {
     uid: string;
-    name: string;
-    disabled: boolean;
-    isBuiltIn: boolean;
-    organization?: IAppOrganization;
 }
-interface IAppRole {
+interface IAuthenticationOrganizationalUnit {
     id: string;
     uid: string;
-    name: string;
-}
-
-interface IMultiTenantEntity {
-    tenant: IAppTenant;
 }
-interface IMultiOrganizationEntity {
-    organization: IAppOrganization;
+interface IAuthenticationContext<TUserContextData> {
+    isAuthenticated: boolean;
+    isAnonymous: boolean;
+    userId?: string;
+    userContext?: TUserContextData;
+    userRoles?: IAuthenticationUserRole[];
+    userPermissions?: IAuthenticationUserPermission[];
+    userOrganizationalUnits?: IAuthenticationOrganizationalUnit[];
 }
-interface IMultiCompanyEntity {
-    company: IAppCompany;
+interface IAuthenticationContextProvider<TUserContext> {
+    getContext(): Promise<IAuthenticationContext<TUserContext>>;
 }
-
-declare class MultiTenancyModule {
+interface IAuthenticationData {
+    user: IAuthUser;
+    roles: IAuthenticationUserRole[];
+    permissions: IAuthenticationUserPermission[];
+    organizationalUnits: IAuthenticationOrganizationalUnit[];
 }
-
-declare const createExpressFileResponse: (res: Response, file: {
-    content: Buffer;
-    contentType: string;
-    name: string;
-}) => StreamableFile;
-
-declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends TypeOrmQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TFacets, TUserContext> {
-    constructor(entityName: string, registry: EntityManagerRegistry);
+interface IAuthenticationMiddleware<TAuthenticationData extends IAuthenticationData, TOutput> {
+    processContext(data: TAuthenticationData): Promise<TOutput>;
+    getPriority(): number;
 }
 
-declare class NestTypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> extends TypeOrmRepository<TEntity, TEntityId> {
-    constructor(repository: Repository<TEntity>);
+type CacheTtl = {
+    value: number;
+    unit: "years" | "months" | "days" | "hours" | "minutes" | "seconds";
+};
+type CacheEntryInfo = {
+    instanceName: string;
+    key: string;
+    expiration: Date;
+    createdOn: Date;
+    updatedOn: Date;
+};
+type CacheEntryDetail = CacheEntryInfo & {
+    data: any;
+};
+interface ICacheInstance {
+    getInstanceName(): string;
+    getEntries(): Promise<CacheEntryInfo[]>;
+    getEntry(key: string): Promise<CacheEntryDetail | undefined>;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, input: {
+        value: T;
+        ttl: CacheTtl;
+    }): Promise<void>;
+    retrieve<T>(key: string, input: {
+        ttl: CacheTtl;
+        valueFactory: () => Promise<T>;
+    }): Promise<T>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
 }
-
-declare abstract class TypeOrmEntitySeeder<TEntity extends ObjectLiteral> extends EntitySeeder<TEntity, FindOneOptions<TEntity>> {
-    protected exists(condition: FindOneOptions<TEntity>): Promise<boolean>;
-    protected create(entity: TEntity): Promise<void>;
-    protected abstract getRepository(): Repository<TEntity>;
+interface ICache {
+    getInstance(instanceName: string): Promise<ICacheInstance>;
 }
 
-declare abstract class NestTypeOrmEntitySeeder<TEntity extends ObjectLiteral> extends TypeOrmEntitySeeder<TEntity> {
-    private readonly registry;
-    protected readonly metadata: EntitySeederProps;
-    constructor(registry: EntityManagerRegistry);
-    get priority(): number | undefined;
-    protected getRepository(): Repository<TEntity>;
+interface IEntitySnapshotService<TEntityId, TEntitySnapshot> {
+    getSnapshot(id: TEntityId): Promise<TEntitySnapshot>;
 }
 
-interface RuntimeErrorInformation {
-    exception: any;
-    request: any;
-    response: any;
+type EntitiesMapOperationsInput<TEntitiesQueryBuilder> = {
+    queryBuilder: TEntitiesQueryBuilder;
+    settings: EntityManagerSettings;
+};
+interface IEntityManagerServiceRoot {
+    locator: ServiceLocator;
+    getEntitiesServicesLocator(): EntitiesServiceLocator;
+    getEntityServicesLocator<TEntity, TEntityId>(entityName: string): EntityServiceLocator<TEntity, TEntityId>;
+    addAuthentication<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>({ provider, }: {
+        provider: TAuthenticationContextProvider;
+    }): void;
+    registerEntity<TEntity, TEntityId, TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(entity: IEntityConfiguration, repository: TRepository): IEntityManagerServiceCollection<TEntity, TEntityId>;
 }
-declare abstract class AppExceptionsFilterBase implements ExceptionFilter {
-    catch(exception: unknown, host: ArgumentsHost): void;
-    protected getExceptionType(exception: any): any;
-    protected getExceptionStack(exception: any): any;
-    protected getExceptionMessage(exception: any): any;
-    protected getErrorStatusCode(exception: any): number;
-    protected abstract logError(info: RuntimeErrorInformation): Promise<void>;
-    protected abstract getCustomErrorStatusCode(exception: any): number | undefined;
+interface IEntityManagerServiceCollection<TEntity, TEntityId> {
+    getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
+    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, unknown, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>(input: EntitiesMapOperationsInput<TEntitiesQueryBuilder>): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addSerializer<TEntitySerializer extends IEntitySerializer<TEntity, TEntityId, unknown, unknown>>(serializer: TEntitySerializer): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addSnapshotService<TEntitySnapshotService extends IEntitySnapshotService<TEntityId, unknown>>(service: TEntitySnapshotService): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addAdapter<TEntityCreateData, TEntityUpdateData, TEntityAdapter extends IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>>(adapter: TEntityAdapter): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addAuthorization<TEntityAuthorizationMiddleware extends IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>({ middleware, }: {
+        middleware: TEntityAuthorizationMiddleware;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    withReplica<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>({ name, options, repository, }: {
+        name: string;
+        options: ReplicaOptions;
+        repository: TRepository;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    withSynchronization<TMappedType, TMapper extends IEntityMapper<TEntity, TMappedType>, TEntityConnector extends IEntityConnector<TEntity, TMappedType>>({ name, options, connector, mapper, }: {
+        name: string;
+        options: ConnectorOptions;
+        connector: TEntityConnector;
+        mapper: TMapper;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
 }
 
-interface IPipelineStepOperationOptionsBuilder<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> {
-    withRollback(definition: RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>): IPipelineStepOperationOptionsBuilder<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>;
-}
-interface IPipelineStepOperationBuilder<TStepInput, TStepOutput, TPipelineInput, TContext> {
-    addOperation(operation: OperationDefinition<TStepInput, TStepOutput, TStepInput, TPipelineInput, TContext>): IPipelineStepOperationOptionsBuilder<TStepInput, TStepOutput, TStepInput, TPipelineInput, TContext>;
-}
-interface IPipelineStepBuilder<TStepInput, TStepOutput, TPipelineInput, TContext> {
-    addStep<TNextStepOutput>(builder: (step: IPipelineStepOperationBuilder<TStepOutput, TNextStepOutput, TPipelineInput, TContext>) => void): IPipelineStepBuilder<TStepOutput, TNextStepOutput, TPipelineInput, TContext>;
-    complete(): PipelineDefinition<TPipelineInput, TStepOutput, TContext>;
+interface IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload> {
+    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
+    getTemplateData(payload: TAugmentedPayload): Promise<TTemplateData>;
 }
-interface IPipelineTemplateBuilder<TPipelineInput, TContext> {
-    addStep<TStepOutput>(builder: (step: IPipelineStepOperationBuilder<TPipelineInput, TStepOutput, TPipelineInput, TContext>) => void): IPipelineStepBuilder<TPipelineInput, TStepOutput, TPipelineInput, TContext>;
+interface IEmailTemplatesCollection {
+    registerTemplate(id: string, template: IEmailTemplate<unknown, unknown, unknown>): void;
+    getTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload>(id: string): IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>;
 }
-
-declare class PipelinesBuilder {
-    private readonly registry;
-    constructor(registry: EntityManagerRegistry);
-    createTemplate<TInput, TContext>(): IPipelineTemplateBuilder<TInput, TContext>;
+type TemplatedEmailInput<TPayload> = {
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    subjectTemplate?: string;
+    templateId: string;
+    languageCode: string;
+    payload: TPayload;
+};
+interface HtmlEmailInput<TPayload> {
+    replyTo?: string;
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    subjectTemplate: string;
+    bodyTemplate: string;
+    payload: TPayload;
 }
-
-declare class PipelinesRunner {
-    private readonly registry;
-    constructor(registry: EntityManagerRegistry);
-    invokePipeline<TPipelineInput, TPipelineOutput, TContext>(definition: PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>, data: {
-        input: TPipelineInput;
-        context: TContext;
-    }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
-    private get controller();
+interface IEmailProvider<TTemplateData> {
+    sendTemplatedEmail<TPayload, TAugmentedPayload>(input: TemplatedEmailInput<TPayload>, template: IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>): Promise<void>;
+    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
 }
-
-declare class PipelineUtils<TPipelineInput, TPipelineOutput, TContext> {
-    getStep: (step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
-    getStepInput: <TStepInput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepInput;
-    getStepOutput: <TStepOutput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepOutput;
+interface IEmailLogger {
+    logTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
+    logHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
 }
 
-declare abstract class NestPipelineTemplate<TPipelineInput, TPipelineOutput, TContext> {
-    protected readonly logger: _punks_backend_core.ILogger;
-    protected readonly utils: PipelineUtils<TPipelineInput, TPipelineOutput, TContext>;
-    private cachedDefinition;
-    protected abstract buildTemplate(builder: IPipelineTemplateBuilder<TPipelineInput, TContext>): PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>;
-    protected isAuthorized(context: TContext): boolean;
-    invoke(input: TPipelineInput): Promise<TPipelineOutput>;
-    execute(data: {
-        input: TPipelineInput;
-        context: TContext;
-    }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
-    private getDefinition;
-    private buildDefinition;
-    private getContext;
-    private get controller();
-    private get registry();
-    protected get metadata(): PipelineTemplateProps;
+declare class EntityManagerException extends Error {
+    constructor(message: string);
 }
-
-declare class PipelineInvocationError extends Error {
-    readonly errorType: PipelineErrorType;
-    readonly innerError: Error | undefined;
-    readonly rawResult: PipelineResult<unknown, unknown>;
-    constructor(errorType: PipelineErrorType, innerError: Error | undefined, rawResult: PipelineResult<unknown, unknown>, message?: string);
+declare enum EntityOperationType {
+    Create = 0,
+    Update = 1,
+    Delete = 2,
+    Read = 3,
+    Search = 4,
+    Find = 5
 }
-
-declare class AwsS3BucketError extends Error {
+declare abstract class EntityManagerUnauthorizedException extends EntityManagerException {
     constructor(message: string);
 }
-
-declare class AppInMemorySettings<T> {
-    private _instance;
-    constructor();
-    initialize(value: T): void;
-    get value(): T;
-}
-
-type AwsBucketPaths = {
-    filesUpload: string;
-};
-type AwsBucketSettings = {
-    awsAccessKeyId?: string;
-    awsSecretAccessKey?: string;
-    region?: string;
-    defaultBucket: string;
-    publicLinksExpirationMinutes: number;
-    paths: AwsBucketPaths;
-};
-
-declare class AwsBucketModule {
-    static forRoot(input: AwsBucketSettings): DynamicModule;
+declare class EntityOperationUnauthorizedException<TEntity> extends EntityManagerUnauthorizedException {
+    private readonly operation;
+    private readonly entity?;
+    constructor(operationType: EntityOperationType, entityName: string, entity?: DeepPartial<TEntity>);
+    get getEntity(): DeepPartial<TEntity> | undefined;
+    get getOperation(): EntityOperationType;
 }
-
-declare class AwsS3BucketProvider implements IBucketProvider {
-    private readonly client;
+declare class EntityNotFoundException<TEntityId> extends EntityManagerException {
+    private readonly entityId;
+    constructor(id?: TEntityId);
+    getEntityId(): TEntityId | undefined;
+}
+declare class MultipleEntitiesFoundException extends EntityManagerException {
     constructor();
-    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
-    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
-    folderCreate(input: BucketFolderEnsureInput): Promise<void>;
-    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
-    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
-    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
-    fileUpload(input: BucketFileUploadInput): Promise<void>;
-    fileDelete(input: BucketFileDeleteInput): Promise<void>;
 }
-
-declare class InMemoryBucketProvider implements IBucketProvider {
-    private inMemoryStorage;
-    private inMemoryFolders;
-    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
-    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
-    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
-    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
-    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
-    fileUpload(input: BucketFileUploadInput): Promise<void>;
-    fileDelete(input: BucketFileDeleteInput): Promise<void>;
+declare class EntityManagerConfigurationError extends EntityManagerException {
+    constructor(message: string);
+}
+declare class MissingEntityIdError extends EntityManagerException {
+    constructor();
 }
 
-type AwsSesEmailTemplateData = {
-    subjectTemplate: string;
-    htmlTemplate: string;
-    from?: string;
-    to?: string[];
-    cc?: string[];
-    bcc?: string[];
-    replyTo?: string;
+type FileData = {
+    content: Buffer;
+    contentType: string;
+    fileName: string;
+    folderPath: string;
+    metadata?: Record<string, any>;
 };
-
-declare abstract class AwsSesEmailTemplate<TPayload, TAugmentedPayload = TPayload> implements IEmailTemplate<AwsSesEmailTemplateData, TPayload, TAugmentedPayload> {
-    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
-    getTemplateData(payload: TAugmentedPayload): Promise<AwsSesEmailTemplateData>;
+type FileDownloadUrl = {
+    downloadUrl: string;
+    contentType: string;
+    fileName: string;
+};
+type FileReference = {
+    fileId: string;
+    reference: string;
+    providerId: string;
+};
+interface IFileManager {
+    uploadFile(file: FileData): Promise<FileReference>;
+    getFileContent(fileId: string): Promise<FileData>;
+    getFileDownloadUrl(fileId: string): Promise<FileDownloadUrl>;
 }
-
-declare const WpAwsSesEmailTemplate: (templateId: string, sendgridTemplateData: AwsSesEmailTemplateData) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-
-type AwsSesSettings = {
-    awsAccessKeyId?: string;
-    awsSecretAccessKey?: string;
-    region?: string;
-    defaultSender: string;
-    defaultCc?: string[];
-    defaultBcc?: string[];
+type FilesReferenceData = {
+    reference: string;
+    providerId: string;
+    metadata?: Record<string, any>;
+    fileName: string;
+    filePath: string;
+    fileSize: number;
+    contentType: string;
 };
-
-declare class AwsEmailModule {
-    static forRoot(input: AwsSesSettings): DynamicModule;
+type FileReferenceRecord = FilesReferenceData & {
+    fileId: string;
+    createdOn: Date;
+    updatedOn: Date;
+};
+interface IFilesReferenceRepository {
+    getReference(fileId: string): Promise<FileReferenceRecord>;
+    createReference(file: FilesReferenceData): Promise<FileReferenceRecord>;
+    updateReference(fileId: string, file: FilesReferenceData): Promise<FileReferenceRecord>;
+    deleteReference(fileId: string): Promise<void>;
 }
-
-type SendgridTemplateType = "template" | "html";
-type SendgridTemplateBaseData = {
-    from?: string;
-    to?: string[];
-    cc?: string[];
-    bcc?: string[];
-    replyTo?: string;
+type FileProviderReference = {
+    reference: string;
 };
-type SendgridEmailTemplateData = SendgridTemplateBaseData & ({
-    type: "template";
-    sendgridTemplateId: string;
-} | {
-    type: "html";
-    subjectTemplate: string | LocalizedTexts;
-    bodyTemplate: string | LocalizedTexts;
-});
-
-declare abstract class SendgridEmailTemplate<TPayload, TAugmentedPayload = TPayload> implements IEmailTemplate<SendgridEmailTemplateData, TPayload, TAugmentedPayload> {
-    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
-    getTemplateData(payload: TAugmentedPayload): Promise<SendgridEmailTemplateData>;
+type FileProviderUploadData = {
+    fileName: string;
+    content: Buffer;
+    contentType: string;
+};
+type FileProviderDownloadData = {
+    content: Buffer;
+};
+type FileProviderDownloadUrl = {
+    downloadUrl: string;
+};
+interface IFileProvider {
+    getProviderId(): string;
+    uploadFile(file: FileProviderUploadData): Promise<FileProviderReference>;
+    deleteFile(reference: FileProviderReference): Promise<void>;
+    downloadFile(reference: FileProviderReference): Promise<FileProviderDownloadData>;
+    getFileProviderDownloadUrl(reference: FileProviderReference): Promise<FileProviderDownloadUrl>;
 }
 
-declare const WpSendgridEmailTemplate: (templateId: string, sendgridTemplateData: SendgridEmailTemplateData) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+type FilterExpression<TEntity> = (entity: TEntity) => boolean;
 
-type SendgridSettings = {
-    apiKey: string;
-    defaultSender: string;
-    defaultReplyTo?: string;
-    defaultCc?: string[];
-    defaultBcc?: string[];
-    loggingEnabled?: boolean;
+type LocalizedMap<T> = {
+    [key: string]: T;
 };
+type LocalizedTexts = LocalizedMap<string>;
 
-declare class SendgridEmailModule {
-    static forRoot(input: SendgridSettings): DynamicModule;
+interface IEventLog<TPayload> {
+    type: string;
+    payload?: TPayload;
+    userId?: string;
+    userName?: string;
+    timestamp: Date;
 }
-
-type SentEmail = {
-    input: TemplatedEmailInput<unknown>;
-    template: IEmailTemplate<void, unknown, unknown>;
-    type: "templated";
-} | {
-    input: HtmlEmailInput<unknown>;
-    type: "html";
-};
-declare class InMemoryEmailProvider implements IEmailProvider<void> {
-    private readonly sentEmails;
-    sendTemplatedEmail<TPayload, TAugmentedPayload>(input: TemplatedEmailInput<TPayload>, template: IEmailTemplate<void, TPayload, TAugmentedPayload>): Promise<void>;
-    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
-    getSentEmails(): SentEmail[];
+interface IEventsTracker<TEventLog extends IEventLog<unknown>> {
+    track(log: TEventLog): Promise<void>;
 }
 
-declare class NestEventEmitter implements IEventEmitter {
-    private eventEmitter;
-    constructor(eventEmitter: EventEmitter2);
-    emit(event: string, ...args: any[]): Promise<void>;
-}
+declare const createContainer: () => IEntityManagerServiceRoot;
 
-interface EntityManagerStaticProviders {
-    modulesContainer: ModulesContainer$1;
-    authenticationProvider?: IAuthenticationContextProvider<unknown>;
-    settings: EntityManagerSettings;
-}
-declare class EntityManagerInitializer {
-    private readonly discover;
-    private readonly registry;
-    private readonly eventEmitter;
-    private readonly logger;
-    constructor(discover: CustomDiscoveryService, registry: EntityManagerRegistry, eventEmitter: NestEventEmitter);
-    initialize(app: INestApplicationContext, staticProviders: EntityManagerStaticProviders): Promise<void>;
-    private registerAuthentication;
-    private registerEntities;
-    private executeInitializers;
-    private executeSeeders;
-    private registerFileProviders;
-    private registerGlobalAuthenticationMiddlewares;
-    private registerBucketProviders;
-    private registerCacheInstances;
-    private registerFilesReferenceRepositoryProviders;
-    private registerEventTrackingProviders;
-    private registerEmailLogger;
-    private registerVersioningProviders;
-    private registerEmailProviders;
-    private registerEmailTemplates;
-    private registerPipelinesServices;
-    private initializeProviders;
-    private discoverEntities;
-    private discoverRepositories;
-    private discoverVersioningProviders;
-    private discoverQueryBuilders;
-    private discoverConverters;
-    private discoverSerializers;
-    private discoverSnapshotService;
-    private discoverAdapters;
-    private discoverAuthMiddlewares;
-    private discoverGlobalAuthenticationMiddlewares;
-    private discoverAppInitializers;
-    private discoverEntitySeeders;
-    private discoverEmailTemplates;
-    private discoverEmailProviders;
-    private discoverEventTrackingProviders;
-    private discoverEmailLogger;
-    private discoverBucketProviders;
-    private discoverCacheInstances;
-    private discoverFileProviders;
-    private discoverFilesReferenceRepositoryProviders;
-}
+declare const toEntitiesImportInput: <TPayload>(request: {
+    format: EntitySerializationFormat;
+    file: Express.Multer.File;
+    payload?: TPayload | undefined;
+}) => EntitiesImportInput<TPayload>;
 
-declare class AppSessionMiddleware implements NestMiddleware {
-    use(req: Request, res: Response, next: NextFunction): void;
-}
+declare const PLATFORM_EVENT_NAMESPACE = "platform";
+declare const PlatformEvents: {
+    Messaging: {
+        EmailSent: string;
+    };
+};
 
-declare class EntityManagerModule implements OnModuleInit {
-    private readonly registry;
-    constructor(registry: EntityManagerRegistry);
-    onModuleInit(): void;
+interface MessagingEmailSentPayload {
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject?: string;
+    body?: string;
+    payload?: any;
+    request?: any;
 }
 
 declare const getLocalizedText: (item: string | LocalizedTexts, languageId: string, defaultLanguageId?: string) => string;
@@ -2795,4 +2803,4 @@ declare const renderHandlebarsTemplate: <TContext extends object>(input: {
 
 declare const newUuid: () => string;
 
-export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppPermission, AppRole, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationModuleSettings, AuthenticationService, AwsBucketModule, AwsBucketSettings, AwsEmailModule, AwsS3BucketError as AwsS2BucketError, AwsS3BucketProvider, AwsSesEmailTemplate, AwsSesEmailTemplateData, AwsSesSettings, BucketContentItem, BucketFileDeleteInput, BucketFileDownloadInput, BucketFilePublicUrlCreateInput, BucketFileUploadInput, BucketFolderContentResult, BucketFolderCreateInput, BucketFolderEnsureInput, BucketFolderExistsInput, BucketFolderListInput, BucketFolderListResult, BucketItemType, BucketProviderProps, CacheEntryDetail, CacheEntryInfo, CacheInstanceProps, CacheService, CacheTtl, ClassType, CurrentUser, CurrentUserData, DeepPartial, EmailLoggerProps, EmailProviderProps, EmailService, EmailTemplateProps, EmailVerifyEmailPayload, EmailVerifyTokenPayload, EntitiesExportFile, EntitiesExportInput, EntitiesExportOptions, EntitiesExportResult, EntitiesImportExportSettings, EntitiesImportInput, EntitiesImportResult, EntitiesImportStatistics, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult, EntityActionsProps, EntityAdapterProps, EntityAuthMiddlewareProps, EntityConnectorProps, EntityConverterProps, EntityExportBucketSettings, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerProps, EntityManagerRegistry, EntityManagerService, EntityManagerSettings, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityProps, EntityQueryBuilderProps, EntityReference, EntityRepositoryProps, EntitySeeder, EntitySeederProps, EntitySerializationFormat, EntitySerializer, EntitySerializerColumnDefinition, EntitySerializerProps, EntitySerializerSheetDefinition, EntitySnapshotService, EntitySnapshotServiceProps, EntityVersionInput, EntityVersionOperation, EntityVersioningProviderProps, EnumType, EventsService, EventsTrackerProps, FileData, FileDownloadUrl, FileProviderDownloadData, FileProviderDownloadUrl, FileProviderProps, FileProviderReference, FileProviderUploadData, FileReference, FileReferenceRecord, FileReferenceRepositoryProps, FilesReferenceData, FilesService, FilterExpression, GlobalAuthenticationMiddlewareProps, HtmlEmailInput, IAppCompany, IAppDirectory, IAppDivision, IAppOrganization, IAppRole, IAppTenant, IAppUser, IAppUserGroup, IAppUserProfile, IAuthOrganizationalUnit, IAuthPermission, IAuthPermissionService, IAuthRole, IAuthRoleService, IAuthService, IAuthUser, IAuthUserContext, IAuthUserOrganization, IAuthUserProfile, IAuthUserRolesService, IAuthUserService, IAuthUserTenant, IAuthUserTokenData, IAuthenticationContext, IAuthenticationContextProvider, IAuthenticationMiddleware, IAuthenticationOrganizationalUnit, IAuthenticationUserPermission, IAuthenticationUserRole, IAuthorizationResult, IBucketProvider, ICache, ICacheDatabaseItem, ICacheInstance, IEmailLogger, IEmailProvider, IEmailTemplate, IEmailTemplatesCollection, IEntitiesCountAction, IEntitiesCountQuery, IEntitiesDeleteAction, IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesDeleteResult$1 as IEntitiesDeleteResult, IEntitiesExportAction, IEntitiesExportCommand, IEntitiesImportAction, IEntitiesImportCommand, IEntitiesQueryBuilder, IEntitiesSampleDownloadAction, IEntitiesSampleDownloadCommand, IEntitiesSearchAction, IEntitiesSearchQuery, IEntitiesSearchResults, IEntitiesSearchResultsPaging, IEntityActions, IEntityAdapter, IEntityAuthorizationMiddleware, IEntityConverter, IEntityCreateAction, IEntityCreateCommand, IEntityDeleteAction, IEntityDeleteCommand, IEntityEventsManager, IEntityExistsAction, IEntityExistsQuery, IEntityFacet, IEntityFacetValue, IEntityFacets, IEntityGetAction, IEntityGetQuery, IEntityManager, IEntityManagerServiceCollection, IEntityManagerServiceRoot, IEntityMapper, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IEntityRepository, IEntitySearchParameters, IEntitySearchResults, IEntitySerializer, IEntitySnapshotService, IEntityUpdateAction, IEntityUpdateCommand, IEntityUpsertAction, IEntityUpsertCommand, IEntityVersionCommand, IEntityVersioningProvider, IEntityVersioningResults, IEntityVersionsCursor, IEntityVersionsFilters, IEntityVersionsReference, IEntityVersionsResultsPaging, IEntityVersionsSearchAction, IEntityVersionsSearchInput, IEntityVersionsSearchParameters, IEntityVersionsSearchQuery, IEntityVersionsSearchResults, IEntityVersionsSorting, IEventLog, IEventsTracker, IFileManager, IFileProvider, IFilesReferenceRepository, IFullTextQuery, IMultiCompanyEntity, IMultiOrganizationEntity, IMultiTenantEntity, IPipelineStepBuilder, IPipelineStepOperationBuilder, IPipelineStepOperationOptionsBuilder, IPipelineTemplateBuilder, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchQueryRelations, ISearchQueryRelationsProperty, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, ITraverseFilters, InMemoryBucketProvider, InMemoryEmailProvider, InvalidCredentialsError, LocalizedMap, LocalizedTexts, MemberOf, MessagingEmailSentPayload, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestEntitySerializer, NestEntitySnapshotService, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NonNullable$1 as NonNullable, OperationDefinition, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PasswordResetEmailPayload, Permissions, PipelineCompletedStepState, PipelineController, PipelineCurrentStepState, PipelineDefinition, PipelineErrorType, PipelineInvocationError, PipelineOperationError, PipelineOperationResult, PipelineOperationResultType, PipelineOperationRollbackResult, PipelineOperationRollbackResultType, PipelineResult, PipelineResultType, PipelineStatus, PipelineStep, PipelineStepErrorType, PipelineStepOperation, PipelineStepResult, PipelineStepResultType, PipelineStepRollbackResult, PipelineStepRollbackResultType, PipelineStepState, PipelineTemplateProps, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, QueryBuilderOperation, RegistrationEmailPayload, ReplicaConfiguration, ReplicaOptions, ReplicationMode, Roles, RolesGuardOptions, RollbackOperationDefinition, RuntimeErrorInformation, SendgridEmailModule, SendgridEmailTemplate, SendgridEmailTemplateData, SendgridSettings, SendgridTemplateBaseData, SendgridTemplateType, SortDirection, SortingType, TemplatedEmailInput, TrackingService, TypeOrmQueryBuilder, TypeOrmRepository, TypeormCacheInstance, UserCreationError, UserCreationInput, UserCreationResult, UserDeleteInput, UserDisableInput, UserEnableInput, UserLoginEventPayload, UserLoginInput, UserLoginResult, UserPasswordChangeInput, UserPasswordResetCompleteInput, UserPasswordResetCompletedEventPayload, UserPasswordResetRequestCallbackTemplate, UserPasswordResetRequestInput, UserPasswordResetRequestResult, UserPasswordResetStartedEventPayload, UserPasswordResetTokenPayload, UserProfile, UserRegisterCallbackTemplate, UserRegistrationCompletedEventPayload, UserRegistrationError, UserRegistrationInput, UserRegistrationResult, UserRegistrationStartedEventPayload, UserTokenVerifyInput, UserTokenVerifyResult, UserVerifyCompleteInput, UserVerifyRequestCallbackTemplate, UserVerifyRequestInput, UserVerifyRequestResult as UserVerifyResetRequestResult, WpAppInitializer, WpAwsSesEmailTemplate, WpBucketProvider, WpCacheInstance, WpEmailLogger, WpEmailProvider, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEntitySerializer, WpEntitySnapshotService, WpEntityVersioningProvider, WpEventsTracker, WpFileProvider, WpFileReferenceRepository, WpGlobalAuthenticationMiddleware, WpPermissionsService, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, buildPermissionsGuard, buildRolesGuard, createContainer, createExpressFileResponse, getLocalizedText, newUuid, renderHandlebarsTemplate, toEntitiesImportInput };
+export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppPermission, AppRole, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationModuleSettings, AuthenticationService, AwsBucketModule, AwsBucketSettings, AwsEmailModule, AwsS3BucketError as AwsS2BucketError, AwsS3BucketProvider, AwsSesEmailTemplate, AwsSesEmailTemplateData, AwsSesSettings, BucketContentItem, BucketFileDeleteInput, BucketFileDownloadInput, BucketFilePublicUrlCreateInput, BucketFileUploadInput, BucketFolderContentResult, BucketFolderCreateInput, BucketFolderEnsureInput, BucketFolderExistsInput, BucketFolderListInput, BucketFolderListResult, BucketItemType, BucketProviderProps, CacheEntryDetail, CacheEntryInfo, CacheInstanceProps, CacheService, CacheTtl, ClassType, CurrentUser, CurrentUserData, DeepPartial, EmailLoggerProps, EmailProviderProps, EmailService, EmailTemplateProps, EmailVerifyEmailPayload, EmailVerifyTokenPayload, EntitiesExportFile, EntitiesExportInput, EntitiesExportOptions, EntitiesExportResult, EntitiesImportExportSettings, EntitiesImportInput, EntitiesImportResult, EntitiesImportStatistics, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult, EntityActionsProps, EntityAdapterProps, EntityAuthMiddlewareProps, EntityConnectorProps, EntityConverterProps, EntityExportBucketSettings, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerProps, EntityManagerRegistry, EntityManagerService, EntityManagerSettings, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityProps, EntityQueryBuilderProps, EntityReference, EntityRepositoryProps, EntitySeeder, EntitySeederProps, EntitySerializationFormat, EntitySerializer, EntitySerializerColumnDefinition, EntitySerializerProps, EntitySerializerSheetDefinition, EntitySnapshotService, EntitySnapshotServiceProps, EntityVersionInput, EntityVersionOperation, EntityVersioningProviderProps, EnumType, EventsService, EventsTrackerProps, FileData, FileDownloadUrl, FileProviderDownloadData, FileProviderDownloadUrl, FileProviderProps, FileProviderReference, FileProviderUploadData, FileReference, FileReferenceRecord, FileReferenceRepositoryProps, FilesReferenceData, FilesService, FilterExpression, GlobalAuthenticationMiddlewareProps, HtmlEmailInput, IAppCompany, IAppDirectory, IAppDivision, IAppOrganization, IAppRole, IAppTenant, IAppUser, IAppUserGroup, IAppUserProfile, IAuthOrganizationalUnit, IAuthPermission, IAuthPermissionService, IAuthRole, IAuthRoleService, IAuthService, IAuthUser, IAuthUserContext, IAuthUserOrganization, IAuthUserProfile, IAuthUserRolesService, IAuthUserService, IAuthUserTenant, IAuthUserTokenData, IAuthenticationContext, IAuthenticationContextProvider, IAuthenticationData, IAuthenticationMiddleware, IAuthenticationOrganizationalUnit, IAuthenticationUserPermission, IAuthenticationUserRole, IAuthorizationResult, IBucketProvider, ICache, ICacheDatabaseItem, ICacheInstance, IEmailLogger, IEmailProvider, IEmailTemplate, IEmailTemplatesCollection, IEntitiesCountAction, IEntitiesCountQuery, IEntitiesDeleteAction, IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesDeleteResult$1 as IEntitiesDeleteResult, IEntitiesExportAction, IEntitiesExportCommand, IEntitiesImportAction, IEntitiesImportCommand, IEntitiesQueryBuilder, IEntitiesSampleDownloadAction, IEntitiesSampleDownloadCommand, IEntitiesSearchAction, IEntitiesSearchQuery, IEntitiesSearchResults, IEntitiesSearchResultsPaging, IEntityActions, IEntityAdapter, IEntityAuthorizationMiddleware, IEntityConverter, IEntityCreateAction, IEntityCreateCommand, IEntityDeleteAction, IEntityDeleteCommand, IEntityEventsManager, IEntityExistsAction, IEntityExistsQuery, IEntityFacet, IEntityFacetValue, IEntityFacets, IEntityGetAction, IEntityGetQuery, IEntityManager, IEntityManagerServiceCollection, IEntityManagerServiceRoot, IEntityMapper, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IEntityRepository, IEntitySearchParameters, IEntitySearchResults, IEntitySerializer, IEntitySnapshotService, IEntityUpdateAction, IEntityUpdateCommand, IEntityUpsertAction, IEntityUpsertCommand, IEntityVersionCommand, IEntityVersioningProvider, IEntityVersioningResults, IEntityVersionsCursor, IEntityVersionsFilters, IEntityVersionsReference, IEntityVersionsResultsPaging, IEntityVersionsSearchAction, IEntityVersionsSearchInput, IEntityVersionsSearchParameters, IEntityVersionsSearchQuery, IEntityVersionsSearchResults, IEntityVersionsSorting, IEventLog, IEventsTracker, IFileManager, IFileProvider, IFilesReferenceRepository, IFullTextQuery, IMultiCompanyEntity, IMultiOrganizationEntity, IMultiTenantEntity, IPipelineStepBuilder, IPipelineStepOperationBuilder, IPipelineStepOperationOptionsBuilder, IPipelineTemplateBuilder, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchQueryRelations, ISearchQueryRelationsProperty, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, ITraverseFilters, InMemoryBucketProvider, InMemoryEmailProvider, InvalidCredentialsError, LocalizedMap, LocalizedTexts, MemberOf, MessagingEmailSentPayload, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestEntitySerializer, NestEntitySnapshotService, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NonNullable$1 as NonNullable, OperationDefinition, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PasswordResetEmailPayload, Permissions, PipelineCompletedStepState, PipelineController, PipelineCurrentStepState, PipelineDefinition, PipelineErrorType, PipelineInvocationError, PipelineOperationError, PipelineOperationResult, PipelineOperationResultType, PipelineOperationRollbackResult, PipelineOperationRollbackResultType, PipelineResult, PipelineResultType, PipelineStatus, PipelineStep, PipelineStepErrorType, PipelineStepOperation, PipelineStepResult, PipelineStepResultType, PipelineStepRollbackResult, PipelineStepRollbackResultType, PipelineStepState, PipelineTemplateProps, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, QueryBuilderOperation, RegistrationEmailPayload, ReplicaConfiguration, ReplicaOptions, ReplicationMode, Roles, RolesGuardOptions, RollbackOperationDefinition, RuntimeErrorInformation, SendgridEmailModule, SendgridEmailTemplate, SendgridEmailTemplateData, SendgridSettings, SendgridTemplateBaseData, SendgridTemplateType, SortDirection, SortingType, TemplatedEmailInput, TrackingService, TypeOrmQueryBuilder, TypeOrmRepository, TypeormCacheInstance, UserCreationError, UserCreationInput, UserCreationResult, UserDeleteInput, UserDisableInput, UserEnableInput, UserLoginEventPayload, UserLoginInput, UserLoginResult, UserPasswordChangeInput, UserPasswordResetCompleteInput, UserPasswordResetCompletedEventPayload, UserPasswordResetRequestCallbackTemplate, UserPasswordResetRequestInput, UserPasswordResetRequestResult, UserPasswordResetStartedEventPayload, UserPasswordResetTokenPayload, UserProfile, UserRegisterCallbackTemplate, UserRegistrationCompletedEventPayload, UserRegistrationError, UserRegistrationInput, UserRegistrationResult, UserRegistrationStartedEventPayload, UserTokenVerifyInput, UserTokenVerifyResult, UserVerifyCompleteInput, UserVerifyRequestCallbackTemplate, UserVerifyRequestInput, UserVerifyRequestResult as UserVerifyResetRequestResult, WpAppInitializer, WpAwsSesEmailTemplate, WpBucketProvider, WpCacheInstance, WpEmailLogger, WpEmailProvider, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEntitySerializer, WpEntitySnapshotService, WpEntityVersioningProvider, WpEventsTracker, WpFileProvider, WpFileReferenceRepository, WpGlobalAuthenticationMiddleware, WpPermissionsService, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, buildPermissionsGuard, buildRolesGuard, createContainer, createExpressFileResponse, getLocalizedText, newUuid, renderHandlebarsTemplate, toEntitiesImportInput };