/// <reference types="node" />
/// <reference types="qs" />
/// <reference types="express" />
/// <reference types="multer" />
import * as _punks_backend_core from '@punks/backend-core';
import { ExcelParseOptions } from '@punks/backend-core';
import * as _nestjs_common from '@nestjs/common';
import { Type as Type$1, INestApplicationContext, CanActivate, ExecutionContext, NestModule, DynamicModule, MiddlewareConsumer, OnModuleInit, OnModuleDestroy, StreamableFile, ExceptionFilter, ArgumentsHost, NestMiddleware } from '@nestjs/common';
import { Repository, EntityTarget, ObjectLiteral, FindOneOptions, FindManyOptions, FindOptionsRelations, ObjectId, FindOptionsWhere, FindOperator, FindOptionsOrder } from 'typeorm';
import { Module } from '@nestjs/core/injector/module';
import { ModulesContainer } from '@nestjs/core/injector/modules-container';
import { MetadataScanner } from '@nestjs/core/metadata-scanner';
import { Reflector, ModulesContainer as ModulesContainer$1 } from '@nestjs/core';
import { JwtService } from '@nestjs/jwt';
import { SchedulerRegistry } from '@nestjs/schedule';
import { CommandBus } from '@nestjs/cqrs';
import * as express from 'express';
import { Response, Request, NextFunction } from 'express';
import { AttributeValue } from '@aws-sdk/client-dynamodb';
import { EventEmitter2 } from '@nestjs/event-emitter';
import * as qs from 'qs';
import * as express_serve_static_core from 'express-serve-static-core';
import { AsyncLocalStorage } from 'async_hooks';

type EntityReference<TEntityId> = {
    id: TEntityId;
};

type EnumType = string | number | symbol;
type SortingType = EnumType;
interface ClassType {
    new (...args: any[]): any;
    constructor: {
        name: string;
    };
}
interface Type<T = any> extends Function {
    new (...args: any[]): T;
}

interface IEntitySearchParameters<TEntity, TSorting, TCursor> {
    query?: IFullTextQuery;
    filters?: ISearchFilters;
    traverse?: ITraverseFilters;
    sorting?: ISearchSorting<TSorting>;
    paging?: ISearchRequestPaging<TCursor>;
    options?: ISearchOptions;
    relations?: ISearchQueryRelations<TEntity>;
}
interface ISearchFilters {
}
interface ITraverseFilters {
    rootOnly?: boolean;
    parentIds?: string[];
}
interface ISearchOptions {
    includeFacets?: boolean;
    includeChildrenMap?: boolean;
    facetsFilters?: ISearchFilters;
}
interface ISearchRequestPaging<TCursor> {
    cursor?: TCursor;
    pageSize: number;
}
interface ISearchSortingField<TSorting> {
    field: TSorting;
    direction: SortDirection$1;
}
interface ISearchSorting<TSorting> {
    fields: ISearchSortingField<TSorting>[];
}
declare enum SortDirection$1 {
    Asc = "asc",
    Desc = "desc"
}
interface IFullTextQuery {
    term: string;
    fields: string[];
}
type ISearchQueryRelationsProperty<TProperty> = TProperty extends Promise<infer I> ? ISearchQueryRelationsProperty<NonNullable<I>> | boolean : TProperty extends Array<infer I> ? ISearchQueryRelationsProperty<NonNullable<I>> | boolean : TProperty extends string ? never : TProperty extends number ? never : TProperty extends boolean ? never : TProperty extends Function ? never : TProperty extends Buffer ? never : TProperty extends Date ? never : TProperty extends object ? ISearchQueryRelations<TProperty> | boolean : boolean;
type ISearchQueryRelations<TEntity> = {
    [P in keyof TEntity]?: P extends "toString" ? unknown : ISearchQueryRelationsProperty<NonNullable<TEntity[P]>>;
};

interface IChildrenMap extends Record<string, {
    count: number;
}> {
}
interface IEntitiesSearchResultsPaging<TCursor> {
    pageIndex: number;
    pageSize: number;
    totPageItems: number;
    totPages: number;
    totItems: number;
    nextPageCursor?: TCursor;
    currentPageCursor?: TCursor;
    prevPageCursor?: TCursor;
}
interface IEntitiesSearchResults<TEntity, TSearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> {
    request: TSearchParameters;
    items: TResult[];
    facets?: TFacets;
    paging?: IEntitiesSearchResultsPaging<TCursor>;
    childrenMap?: IChildrenMap;
}

interface IEntityVersionsReference {
    entityId: string;
}
interface IEntityVersionsFilters {
    timestampFrom?: Date;
    timestampTo?: Date;
}
interface IEntityVersionsSorting {
    direction: SortDirection$1;
}
declare class IEntityVersionsCursor<TCursor> {
    cursor?: TCursor;
    pageSize: number;
}
interface IEntityVersionsSearchParameters<TCursor> {
    entity: IEntityVersionsReference;
    filters?: IEntityVersionsFilters;
    sorting?: IEntityVersionsSorting;
    paging?: IEntityVersionsCursor<TCursor>;
}
interface IEntityVersionsResultsPaging<TCursor> {
    pageIndex: number;
    pageSize: number;
    totPageItems: number;
    totPages: number;
    totItems: number;
    nextPageCursor?: TCursor;
    currentPageCursor?: TCursor;
    prevPageCursor?: TCursor;
}
interface IEntityVersionsSearchResults<TResult, TCursor> {
    paging?: IEntityVersionsResultsPaging<TCursor>;
    items: TResult[];
}
interface IEntityVersionsSearchRequest<TCursor> {
    params: IEntityVersionsSearchParameters<TCursor>;
}
interface IEntityVersionsSearchResponse<TResult, TCursor> {
    request: IEntityVersionsSearchRequest<TCursor>;
    paging?: IEntityVersionsResultsPaging<TCursor>;
    items: TResult[];
}

type EntryValidationError = {
    errorCode: string;
    value?: any;
    payload?: any;
};
type EntryValidationResult = {
    isValid: boolean;
    validationErrors: EntryValidationError[];
};
type ImportEntryValidationError = {
    errorCode: string;
    column: {
        name: string;
        key: string;
        value?: any;
    };
};
type ImportEntryValidationResult = {
    isValid: boolean;
    validationErrors: ImportEntryValidationError[];
};
type EntitySerializerColumnParser = (value: any) => any;
type EntitySerializerColumnParseAction<TSheetItem> = (value: any, item: TSheetItem) => void;
type EntitySerializerColumnConverter<TSheetItem> = (value: any, item: TSheetItem) => any;
type EntitySerializerColumnValidator<TSheetItem> = {
    key: string;
    fn: (item: TSheetItem) => EntryValidationResult;
};
type EntitySerializerSheetCustomParser = "date";
type EntitySerializerColumnModifier = "trim" | "lowercase" | "uppercase";
type EntitySerializerColumnDefinition<TSheetItem> = {
    name: string;
    aliases?: string[];
    key: string;
    selector: keyof TSheetItem | ((item: TSheetItem) => any);
    colSpan?: number;
    sampleValue?: any;
    parser?: EntitySerializerColumnParser;
    parseAction?: EntitySerializerColumnParseAction<TSheetItem>;
    converter?: EntitySerializerColumnConverter<TSheetItem>;
    validators?: EntitySerializerColumnValidator<TSheetItem>[];
    idColumn?: boolean;
    sheetParser?: EntitySerializerSheetCustomParser;
    array?: boolean;
    arraySeparator?: string | RegExp;
    modifiers?: EntitySerializerColumnModifier[];
};
type EntitySerializerSheetOptions = {
    name?: string;
    useTypeColumn?: boolean;
};
type EntitySerializerSheetDefinition<TSheetItem> = {
    autoColumns?: boolean;
    columns: EntitySerializerColumnDefinition<TSheetItem>[];
    sheet?: EntitySerializerSheetOptions;
    options?: ExcelParseOptions;
};
type EntityExportFile = {
    content: Buffer;
    contentType: string;
    fileName: string;
};
declare enum EntitySerializationFormat {
    Csv = "csv",
    Json = "json",
    Xlsx = "xlsx"
}
type ImportEntry<TSheetItem, TEntityId> = {
    id?: TEntityId;
    item: TSheetItem;
    rowIndex: number;
    status: ImportEntryValidationResult;
};
interface IEntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem, TPayload = unknown> {
    export(filters?: TEntitySearchParameters, payload?: TPayload): Promise<TSheetItem[]>;
    import(items: TSheetItem[], payload?: TPayload): Promise<void>;
    serialize(items: TSheetItem[], format: EntitySerializationFormat, payload?: TPayload): Promise<EntityExportFile>;
    parse<TPayload>(data: Buffer, format: EntitySerializationFormat, payload?: TPayload): Promise<ImportEntry<TSheetItem, TEntityId>[]>;
    createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
}

type EntitiesExportOptions = {
    format: EntitySerializationFormat;
};
type EntitiesExportFile = {
    name: string;
    content: Buffer;
    contentType: string;
};
type EntitiesExportResult = {
    file: EntitiesExportFile;
    downloadUrl: string;
};
type EntitiesExportInput<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TPayload = unknown> = {
    filter?: TEntitySearchParameters;
    options: EntitiesExportOptions;
    payload?: TPayload;
};
type EntityExportBucketSettings = {
    bucket: string;
    publicLinksExpirationMinutes: number;
    rootFolderPath?: string;
};
type EntitiesImportExportSettings = {
    exportBucket: EntityExportBucketSettings;
};
type EntitiesSampleDownloadOptions = {
    format: EntitySerializationFormat;
};
type EntitiesSampleDownloadResult = {
    file: EntitiesExportFile;
    downloadUrl: string;
};

type EntitiesImportInputFile = {
    fileName: string;
    content: Buffer;
    contentType: string;
};
declare enum InvalidEntityHandling {
    Skip = "skip",
    Fail = "fail"
}
type EntitiesImportInput<TPayload> = {
    format: EntitySerializationFormat;
    file: EntitiesImportInputFile;
    payload?: TPayload;
    options?: {
        invalidEntitiesHandling: InvalidEntityHandling;
    };
};
type EntitiesImportStatistics = {
    importedCount: number;
    skippedCount: number;
    updatedCount: number;
    createdCount: number;
    unchangedCount: number;
};
type EntitiesImportResult = {
    statistics: EntitiesImportStatistics;
};

type EntitiesParseInputFile = {
    fileName: string;
    content: Buffer;
    contentType: string;
};
type EntitiesParseError = {
    fieldName: string;
    errorType: string;
};
type EntitiesParseResultItem<TItem> = {
    isValid: boolean;
    item: TItem;
    errors: EntitiesParseError[];
};
type EntitiesParseResult<TItem> = {
    entries: ImportEntry<unknown, unknown>[];
};
type EntitiesParseInput<TPayload> = {
    format: EntitySerializationFormat;
    file: EntitiesParseInputFile;
    payload?: TPayload;
};

declare enum EntityVersionOperation {
    Create = "create",
    Update = "update",
    Upsert = "upsert",
    Delete = "delete"
}
type EntityVersionInput<TEntity, TEntityId> = {
    operationType: EntityVersionOperation;
    entityType: string;
    entityId: TEntityId;
    data?: TEntity;
    modifiedByUserId?: string;
};
interface IEntityVersioningResults<TResult, TCursor> {
    paging?: IEntityVersionsResultsPaging<TCursor>;
    items: TResult[];
}
interface IEntityVersionsSearchInput<TCursor> {
    entityType: string;
    params: IEntityVersionsSearchParameters<TCursor>;
}
interface IEntityVersioningProvider {
    isEnabled(): boolean;
    createVersion<TEntity, TEntityId>(input: EntityVersionInput<TEntity, TEntityId>): Promise<void>;
    searchVersions<TEntity, TCursor>(input: IEntityVersionsSearchInput<TCursor>): Promise<IEntityVersioningResults<TEntity, TCursor>>;
}

interface IEntityCreateCommand<TEntity, TEntityId, TEntityCreateData> {
    execute(input: TEntityCreateData): Promise<EntityReference<TEntityId>>;
}
interface IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> {
    execute(id: TEntityId, data: TEntityUpdateData): Promise<EntityReference<TEntityId>>;
}
interface IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> {
    execute(id: TEntityId, data: TEntityUpdateData): Promise<EntityReference<TEntityId>>;
}
interface IEntityDeleteCommand<TEntity, TEntityId> {
    execute(id: TEntityId): Promise<void>;
}
type EntityVersionCommandInput<TEntity, TEntityId> = {
    operation: EntityVersionOperation;
    id: TEntityId;
    entity?: TEntity;
};
interface IEntityVersionCommand<TEntity, TEntityId> {
    execute(input: EntityVersionCommandInput<TEntity, TEntityId>): Promise<void>;
}
interface IEntitiesDeleteParameters<TSorting> {
    filters?: ISearchFilters;
    sorting?: ISearchSorting<TSorting>;
}
interface IEntitiesDeleteResult$1 {
    deletedCount: number;
}
interface IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> {
    execute(params: TEntitiesDeleteParameters): Promise<IEntitiesDeleteResult$1>;
}
interface IEntitiesExportCommand<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor> {
    execute<TPayload>(input: EntitiesExportInput<TEntity, TEntitySearchParameters, TSorting, TCursor, TPayload>): Promise<EntitiesExportResult>;
}
interface IEntitiesImportCommand<TEntity> {
    execute(input: EntitiesImportInput<unknown>): Promise<EntitiesImportResult>;
}
interface IEntitiesParseCommand<TEntity> {
    execute(input: EntitiesParseInput<unknown>): Promise<EntitiesParseResult<unknown>>;
}
interface IEntitiesSampleDownloadCommand<TEntity> {
    execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;
}
interface IEntityUpsertByParameters<TEntity, TEntityFilters extends ISearchFilters> {
    filter: TEntityFilters;
    data: Partial<TEntity>;
}
interface IEntityUpsertByResult {
    id: string;
}
interface IEntityUpsertByCommand<TEntity, TEntityFilters extends ISearchFilters> {
    execute(params: IEntityUpsertByParameters<TEntity, TEntityFilters>): Promise<IEntityUpsertByResult>;
}

declare class PermissionsChecker<TUserContext> {
    hasAny(context: IAuthenticationContext<TUserContext>, permissions: string[]): boolean;
    hasAll(context: IAuthenticationContext<TUserContext>, permissions: string[]): boolean;
}

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>;
}

type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
type NonNullable$1<T> = T;

type PipelineStepReference = {
    index: number;
    key?: string;
    name: string;
};
type PipelineStepState<TPipelineInput, TContext, TStepInput> = {
    reference: PipelineStepReference;
    context: TContext;
    stepInput: TStepInput;
    pipelineInput: TPipelineInput;
    previousStep?: PipelineCompletedStepState<TPipelineInput, TContext, any, TStepInput>;
};
type PipelineCompletedStepState<TPipelineInput, TContext, TStepInput, TStepOutput> = PipelineStepState<TPipelineInput, TContext, TStepInput> & {
    stepOutput?: TStepOutput;
};
type PipelineCurrentStepState<TPipelineInput, TContext, TStepInput> = PipelineStepState<TPipelineInput, TContext, TStepInput> & {};
type OperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
    key?: string;
    name: string;
    action: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<TOperationOutput> | TOperationOutput;
    precondition?: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<boolean> | boolean;
    skipIf?: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<boolean> | boolean;
};
type RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
    name: string;
    action: (input: TOperationInput, output: TOperationOutput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<void> | void;
};
type PipelineStepOperation<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
    key?: string;
    name: string;
    operation: OperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>;
    rollbackOperations?: RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>[];
};
type PipelineStep<TStepInput, TStepOutput, TPipelineInput, TContext> = {
    name: string;
    operations: PipelineStepOperation<TStepInput, TStepOutput, TStepInput, TPipelineInput, TContext>[];
    outputsReducer?: (results: unknown[]) => TStepOutput;
};
type PipelineDefinition<TPipelineInput, TPipelineOutput, TContext> = {
    steps: PipelineStep<unknown, unknown, TPipelineInput, TContext>[];
};
type PipelineOperationError = {
    message: string;
    stackTrace?: string;
    exception?: Error;
};
type PipelineOperationResult<TOperationInput, TOperationOutput> = {
    key?: string;
    name: string;
    input: TOperationInput;
} & ({
    type: "success";
    output: TOperationOutput;
} | {
    type: "skipped";
} | {
    type: "preconditionFailed";
} | {
    type: "error" | "rollbackCompleted";
    error: PipelineOperationError;
} | {
    type: "rollbackFailed";
    rollbackError: PipelineOperationError;
    error: PipelineOperationError;
});
type PipelineOperationResultType = PipelineOperationResult<unknown, unknown>["type"];
type PipelineOperationRollbackResult = {
    type: "success" | "skipped";
} | {
    type: "error";
    error: PipelineOperationError;
};
type PipelineOperationRollbackResultType = PipelineOperationRollbackResult["type"];
declare enum PipelineStepErrorType {
    FailedPrecondition = "failedPrecondition",
    OperationError = "operationError",
    RollbackError = "rollbackError",
    GenericError = "genericError"
}
type PipelineStepResult<TStepInput, TStepOutput> = {
    input: TStepInput;
    operationResults: PipelineOperationResult<unknown, unknown>[];
} & ({
    type: "success";
    output: TStepOutput;
} | {
    type: "error";
    errorType: PipelineStepErrorType;
});
type PipelineStepResultType = PipelineStepResult<unknown, unknown>["type"];
type PipelineStepRollbackResult = {} & ({
    type: "success";
} | {
    type: "error";
});
type PipelineStepRollbackResultType = PipelineStepRollbackResult["type"];
declare enum PipelineErrorType {
    FailedPrecondition = "failedPrecondition",
    OperationError = "operationError",
    RollbackError = "rollbackError",
    Unauthorized = "unauthorized",
    GenericError = "genericError"
}
type PipelineResult<TPipelineInput, TPipelineOutput> = {
    stepResults: PipelineStepResult<unknown, unknown>[];
    input: TPipelineInput;
} & ({
    type: "success";
    output: TPipelineOutput;
} | {
    type: "error";
    errorType: PipelineErrorType;
    exception?: Error;
    output?: TPipelineOutput;
});
type PipelineResultType = PipelineResult<unknown, unknown>["type"];
declare enum PipelineStatus {
    Initializing = "initializing",
    Running = "running",
    RollbackInProgress = "rollbackInProgress",
    Completed = "completed",
    Failed = "failed"
}

interface IEntityCreateCommandAdapter<TEntity, TEntityCreateData> {
    createDataToEntity(data: TEntityCreateData, context: IAuthenticationContext<unknown>): DeepPartial<TEntity>;
}
interface IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
    updateDataToEntity(data: TEntityUpdateData, context: IAuthenticationContext<unknown>): DeepPartial<TEntity>;
}
interface IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> extends IEntityCreateCommandAdapter<TEntity, TEntityCreateData>, IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
}

interface IAuthorizationResult {
    isAuthorized: boolean;
}
interface IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext> {
    canSearch(context: TAuthenticationContext): Promise<IAuthorizationResult>;
    canRead(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
    canCreate(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
    canUpdate(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
    canDelete(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
    canDeleteItems(context: TAuthenticationContext): Promise<IAuthorizationResult>;
}

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 BucketFileExistsInput = {
    bucket: string;
    filePath: 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;
};
type BucketFileDeleteInput = {
    bucket: string;
    filePath: string;
};
type BucketFileCopyInput = {
    bucket: string;
    filePath: string;
    targetBucket: string;
    targetPath: string;
};
type BucketFileMoveInput = {
    bucket: string;
    filePath: string;
    targetBucket: string;
    targetPath: string;
};
interface IBucketProvider {
    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
    fileExists(input: BucketFileExistsInput): Promise<boolean>;
    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
    fileUpload(input: BucketFileUploadInput): Promise<void>;
    fileDelete(input: BucketFileDeleteInput): Promise<void>;
}

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>;
}

interface IEntityMapper<TEntity, TMappedEntity> {
    mapEntity(entity: TEntity): Promise<TMappedEntity>;
}

interface IEntityConnector<TEntity, TEntityId, TMappedType> {
    syncEntity(entity: TMappedType): Promise<void>;
    deleteEntity(id: TEntityId): Promise<void>;
}
interface IConnectorsConfiguration<TEntity> {
    configureConnector<TEntityConnector extends IEntityConnector<TEntity, unknown, TMappedType>, TMappedType, TMapper extends IEntityMapper<TEntity, TMappedType>>(name: string, options: ConnectorOptions, connector: TEntityConnector, mapper: TMapper): void;
    getConnector(name: string): ConnectorConfiguration<TEntity>;
    getConnectors(): ConnectorConfiguration<TEntity>[];
}
declare enum ConnectorMode {
    Sync = 0,
    Async = 1
}
type ConnectorOptions = {
    mode: ConnectorMode;
    enabled?: boolean;
};
type ConnectorConfiguration<TEntity> = {
    name: string;
    options: ConnectorOptions;
    connector: IEntityConnector<TEntity, unknown, unknown>;
    mapper: IEntityMapper<TEntity, unknown>;
};
interface IEntityConnectorSyncManager<TEntity> {
    syncEntity(entity: TEntity): Promise<void>;
}
interface IEntityConnectorDeleteManager<TEntity, TEntityId> {
    deleteEntity(entityId: TEntityId): Promise<void>;
}

interface IEntitiesSearchActionConverter<TEntity, TListItemDto> {
    toListItemDto(entity: TEntity): TListItemDto | Promise<TListItemDto>;
}
interface IEntityGetActionConverter<TEntity, TEntityDto> {
    toEntityDto(entity: TEntity): TEntityDto | Promise<TEntityDto>;
}
interface IEntityCreateActionConverter<TEntity, TEntityDto, TEntityCreateDto> {
    createDtoToEntity(data: TEntityCreateDto, context?: IAuthenticationContext<unknown>): DeepPartial<TEntity>;
    toEntityDto(entity: TEntity): TEntityDto | Promise<TEntityDto>;
}
interface IEntityUpdateActionConverter<TEntity, TEntityDto, TEntityUpdateDto> {
    toEntityDto(entity: TEntity): TEntityDto | Promise<TEntityDto>;
    updateDtoToEntity(data: TEntityUpdateDto, context?: IAuthenticationContext<unknown>): DeepPartial<TEntity>;
}
interface IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> extends IEntitiesSearchActionConverter<TEntity, TListItemDto>, IEntityGetActionConverter<TEntity, TEntityDto>, IEntityCreateActionConverter<TEntity, TEntityDto, TEntityCreateDto>, IEntityUpdateActionConverter<TEntity, TEntityDto, TEntityUpdateDto> {
}

interface IEmailTemplateMiddleware {
    processPayload(payload: unknown): Promise<unknown>;
    processInput(input: TemplatedEmailInput<unknown>): Promise<TemplatedEmailInput<unknown>>;
}
interface IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload> {
    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
    getTemplateData(payload: TAugmentedPayload): Promise<TTemplateData>;
}
interface IEmailTemplatesCollection {
    registerTemplate(id: string, template: IEmailTemplate<unknown, unknown, unknown>): void;
    getTemplate<TTemplateData, TPayload, TAugmentedPayload = TPayload>(id: string): IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>;
}
type EmailAttachmentData = {
    content: string | Buffer;
    filename: string;
    type?: string;
    disposition?: string;
    contentId?: string;
};
type TemplatedEmailInput<TPayload> = {
    from?: string;
    to?: string[];
    cc?: string[];
    bcc?: string[];
    subjectTemplate?: string;
    templateId: string;
    languageCode: string;
    payload: TPayload;
    attachments?: EmailAttachmentData[];
};
interface HtmlEmailInput<TPayload> {
    replyTo?: string;
    from?: string;
    to?: string[];
    cc?: string[];
    bcc?: string[];
    subjectTemplate: string;
    bodyTemplate: string;
    payload: TPayload;
    attachments?: EmailAttachmentData[];
}
type EmailSendOptions = {
    sandboxMode?: boolean;
    forceDelivery?: boolean;
};
interface IEmailProvider<TTemplateData> {
    sendTemplatedEmail<TPayload, TAugmentedPayload>(input: TemplatedEmailInput<TPayload>, template: IEmailTemplate<TTemplateData, TPayload, TAugmentedPayload>, options?: EmailSendOptions): Promise<void>;
    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>, options?: EmailSendOptions): Promise<void>;
}
interface IEmailLogger {
    logTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>): Promise<void>;
    logHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
}

interface IEntityEventsManager<TEntity, TEntityId> {
    processEntityCreatedEvent(entity: TEntity): Promise<void>;
    processEntityUpdatedEvent(entity: TEntity): Promise<void>;
    processEntityDeletedEvent(id: TEntityId): Promise<void>;
}
interface IEventEmitter {
    emit(event: string, ...args: any[]): Promise<void>;
}

type FileData = {
    fileId?: string;
    content: Buffer;
    contentType: string;
    fileName: string;
    folderPath: string;
    storageFilePath?: string;
    storageBucket?: 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>;
    removeFile(fileId: string): Promise<void>;
    getFileContent(fileId: string): Promise<FileData>;
    getFileDownloadUrl(fileId: string): Promise<FileDownloadUrl>;
}
type FilesReferenceData = {
    reference: string;
    providerId: string;
    metadata?: Record<string, any>;
    fileId?: string;
    fileName: string;
    filePath: string;
    fileSize: number;
    contentType: string;
};
type FileReferenceRecord = FilesReferenceData & {
    fileId: string;
    createdOn: Date;
    updatedOn: Date;
};
interface IFilesReferenceRepository {
    searchReference({ reference, providerId, }: {
        reference: string;
        providerId: string;
    }): Promise<FileReferenceRecord>;
    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;
    bucket?: string;
};
type FileProviderUploadData = {
    fileId?: string;
    fileName: string;
    filePath?: string;
    content: Buffer;
    contentType: string;
    bucket?: 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>;
    get defaultBucket(): string;
}

interface IEntityFacetValue<T> {
    value: T;
    label: string;
    count: number;
}
interface IEntityFacet<T> {
    values: IEntityFacetValue<T>[];
}
interface IEntityFacets {
}
interface IEntitySearchResults<TEntity, TSearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> {
    request: TSearchParameters;
    items: TResult[];
    Facets?: TFacets;
    paging?: ISearchResultsPaging<TCursor>;
}
interface ISearchResultsPaging<TCursor> {
    pageIndex: number;
    pageSize: number;
    totPages: number;
    nextPageCursor?: TCursor;
    currentPageCursor?: TCursor;
    prevPageCursor?: TCursor;
}

interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
    get get(): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
    get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
    get find(): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    get exists(): IEntityExistsQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
    get count(): IEntitiesCountQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
    get version(): IEntityVersionCommand<TEntity, TEntityId>;
    get create(): IEntityCreateCommand<TEntity, TEntityId, TEntityCreateData>;
    get update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
    get upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
    get upsertBy(): IEntityUpsertByCommand<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
    get delete(): IEntityDeleteCommand<TEntity, TEntityId>;
    get deleteItems(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
    get import(): IEntitiesImportCommand<TEntity>;
    get parse(): IEntitiesParseCommand<TEntity>;
    get export(): IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    get sampleDownload(): IEntitiesSampleDownloadCommand<TEntity>;
    get versions(): IEntityVersionsSearchQuery<TEntity, TCursor>;
}

type MediaUploadInput = {
    fileName: string;
    content: Buffer;
    contentType?: string;
    folderId?: string;
};
type MediaReference = {
    ref: string;
};
type MediaItemReference = {
    id: string;
    ref: string;
    folderId?: string;
};
type IMediaProvider = {
    mediaUpload(input: MediaUploadInput): Promise<MediaReference>;
    mediaDelete(input: MediaReference): Promise<void>;
    mediaDownload(input: MediaReference): Promise<Buffer>;
    getFileName(input: MediaReference): string;
    getProviderId(): string;
};
type MediaReferenceRecord = {
    id: string;
    ref: string;
    folderId?: string;
    createdOn: Date;
    updatedOn: Date;
};
type MediaReferenceCreateInput = {
    media: MediaReference;
    fileName: string;
    contentType?: string;
    folderId?: string;
    providerId: string;
};
type IMediaReferenceRepository = {
    getReference(file: MediaReference): Promise<MediaReferenceRecord>;
    createReference(input: MediaReferenceCreateInput): Promise<MediaReferenceRecord>;
    updateReferenceFolder(file: MediaReference, folderId: string | undefined): Promise<void>;
    deleteReference(file: MediaReference): Promise<void>;
    getFolderReferences(folderId?: string): Promise<MediaReferenceRecord[]>;
};
type MediaFolderRecord = {
    id: string;
    name: string;
    createdOn: Date;
    updatedOn: Date;
};
type IMediaFolderRepository = {
    folderCreate(input: {
        name: string;
        parentId?: string;
        organizationId?: string;
    }): Promise<MediaFolderRecord>;
    folderRename(id: string, name: string): Promise<void>;
    folderMove(id: string, parentId?: string): Promise<void>;
    folderDelete(id: string): Promise<void>;
    foldersList(parentId?: string): Promise<MediaFolderRecord[]>;
    folderFind(name: string, parentId?: string): Promise<MediaFolderRecord>;
};
type MediaFolderCreateInput = {
    folderName: string;
    parentId?: string;
    organizationId?: string;
};
type MediaFolderReference = {
    id: string;
    name: string;
};
type MediaFolderRenameInput = {
    id: string;
    folderName?: string;
};
type MediaFolderMoveInput = {
    id: string;
    folderId?: string;
};
type MediaInfo = {
    ref: string;
    fileName: string;
};
type MediaFolderEnsureInput = {
    path: string[];
    organizationId?: string;
};
type IMediaLibraryManager = {
    mediaUpload(input: MediaUploadInput): Promise<MediaItemReference>;
    mediaDelete(input: MediaReference): Promise<void>;
    mediaDownload(input: MediaReference): Promise<Buffer>;
    folderEnsure(input: MediaFolderEnsureInput): Promise<MediaFolderReference>;
    folderCreate(input: MediaFolderCreateInput): Promise<MediaFolderReference>;
    folderDelete(input: MediaFolderReference): Promise<void>;
    folderMove(input: MediaFolderMoveInput): Promise<void>;
    folderRename(input: MediaFolderRenameInput): Promise<void>;
    foldersList(parent?: MediaFolderReference): Promise<MediaFolderReference[]>;
    getFolderMedia(input: MediaFolderReference): Promise<MediaInfo[]>;
};

type LockItem = {
    uid: string;
    lockedBy?: string;
    createdOn: Date;
};
type LockAcquireInput = {
    lockUid: string;
    requestedBy?: string;
};
type LockAcquireResult = {
    available: boolean;
    lockItem: LockItem;
};
type LockReleaseInput = {
    lockUid: string;
};
declare class LockNotFoundError extends Error {
}
interface ILockRepository {
    acquireLock(input: LockAcquireInput): Promise<LockAcquireResult>;
    releaseLock(input: LockReleaseInput): Promise<void>;
    getLock(lockUid: string): Promise<LockItem | undefined>;
}
interface ExecuteSequentialInput<T> {
    lockUid: string;
    requestedBy?: string;
    lockTimeout?: number;
    lockPolling?: number;
    operation: () => Promise<T>;
}
declare class ExclusiveOperationResult<T> {
    skipped: boolean;
    result?: T;
}
interface ExecuteExclusiveInput<T> {
    lockUid: string;
    requestedBy?: string;
    lockTimeout?: number;
    operation: () => Promise<T>;
}
interface IOperationLockService {
    executeSequential<T>(input: ExecuteSequentialInput<T>): Promise<T>;
    executeExclusive<T>(input: ExecuteExclusiveInput<T>): Promise<ExclusiveOperationResult<T>>;
}

interface IPipelineInstance<TPipelineInput, TPipelineOutput, TContext> {
    execute(): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
}
interface IPipelinesController {
    createInstance<TPipelineInput, TPipelineOutput, TContext>(definition: PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>, input: TPipelineInput, context: TContext | undefined): Promise<IPipelineInstance<TPipelineInput, TPipelineOutput, TContext>>;
}
type PipelineConcurrency = "exclusive" | "sequential";

interface IEntitiesDeleteResult {
    deletedCount: number;
}
interface IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition> {
    exists(id: TEntityId): Promise<boolean>;
    existsBy(condition: TGetConditions): Promise<boolean>;
    get(id: TEntityId): Promise<TEntity | undefined>;
    getBy(condition: TGetConditions): Promise<TEntity | undefined>;
    all(): Promise<TEntity[]>;
    find(condition: TFindCondition): Promise<TEntity[]>;
    findOne(condition: TFindCondition): Promise<TEntity | undefined>;
    findOneOrFail(condition: TFindCondition): Promise<TEntity>;
    findById(id: TEntityId[]): Promise<TEntity[]>;
    count(condition: TFindCondition): Promise<number>;
    delete(id: TEntityId): Promise<void>;
    deleteBy(condition: TDeleteCondition): Promise<IEntitiesDeleteResult>;
    create(entity: DeepPartial<TEntity>): Promise<TEntity>;
    update(id: TEntityId, entity: DeepPartial<TEntity>): Promise<TEntity>;
    updateBy(entity: DeepPartial<TEntity>, condition: TUpdateCondition): Promise<TEntity[]>;
    upsert(id: TEntityId, entity: DeepPartial<TEntity>): Promise<TEntity>;
    upsertBy({ data, filter, }: {
        data: Partial<TEntity>;
        filter: TFindCondition;
    }): Promise<EntityReference<string>>;
}

interface IReplicasConfiguration<TEntity, TEntityId> {
    configureReplica<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(name: string, options: ReplicaOptions, repository: TRepository): void;
    getReplica(name: string): ReplicaConfiguration<TEntity, TEntityId>;
    getReplicas(): ReplicaConfiguration<TEntity, TEntityId>[];
}
declare enum ReplicationMode {
    Sync = 0,
    Async = 1
}
type ReplicaOptions = {
    mode: ReplicationMode;
    enabled?: boolean;
};
type ReplicaConfiguration<TEntity, TEntityId> = {
    name: string;
    options: ReplicaOptions;
    repository: IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>;
};
interface IEntityReplicaDeleteManager<TEntity, TEntityId> {
    deleteReplicas(entityId: TEntityId): Promise<void>;
}
interface IEntityReplicaSyncManager<TEntity> {
    syncReplicas(entity: TEntity): Promise<void>;
}

type AppSecretType = "string" | "number" | "boolean" | "json";
type AppSecretDefinition = {
    key: string;
    type: AppSecretType;
    hidden: boolean;
    defaultValue?: any;
};
type AppSecret<TValue> = {
    key: string;
    value: TValue;
    type: AppSecretType;
    hidden: boolean;
    timestamp: number;
};
type AppSecretInput<TValue> = {
    key: string;
    value: TValue;
};
type AppSecretsPageMetadata = {
    tags?: {
        key: string;
        value: string;
    }[];
};
interface ISecretsProvider {
    getSecrets(pageName: string): Promise<AppSecret<any>[]>;
    setSecret<TValue>(pageName: string, secret: AppSecret<TValue>): Promise<void>;
    defineSecret(pageName: string, definition: AppSecretDefinition): Promise<void>;
    pageInitialize(pageName: string, metadata: AppSecretsPageMetadata): Promise<void>;
    pageEnsure(pageName: string, metadata: AppSecretsPageMetadata): Promise<void>;
    pageExists(pageName: string): Promise<boolean>;
}

type EntityManagerSettings = {
    importExport: EntitiesImportExportSettings;
    defaultBucketProvider: string;
    defaultFilesProvider: string;
    defaultMediaProvider: string;
};
type EntityVersioningOptions$1 = {
    enabled: boolean;
};
type IEntityConfiguration = {
    name: string;
    versioning?: EntityVersioningOptions$1;
};

interface IEntitySnapshotService<TEntityId, TEntitySnapshot> {
    getSnapshot(id: TEntityId): Promise<TEntitySnapshot>;
}

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 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;
    private logger;
    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 EntitiesServiceLocator {
    private readonly provider;
    constructor(provider: ServiceLocator);
    getProvider(): ServiceLocator;
    registerSettings(settings: EntityManagerSettings): this;
    resolveSettings(): EntityManagerSettings;
    resolveEventEmitter<TEventEmitter extends IEventEmitter>(): TEventEmitter;
    registerEventEmitter<TEventEmitter extends IEventEmitter>(instance: TEventEmitter): void;
    resolveEmailProvider<TEmailProvider extends IEmailProvider<unknown>>(): TEmailProvider;
    registerEmailProvider<TEmailProvider extends IEmailProvider<unknown>>(instance: TEmailProvider): void;
    resolveEntityVersioningProvider<TEntityVersioningProvider extends IEntityVersioningProvider>(): TEntityVersioningProvider;
    registerEntityVersioningProvider<TEntityVersioningProvider extends IEntityVersioningProvider>(instance: TEntityVersioningProvider): void;
    resolveDefaultBucketProvider<TBucketProvider extends IBucketProvider>(): TBucketProvider;
    resolveDefaultFilesProvider<TFileProvider extends IFileProvider>(): TFileProvider;
    resolveDefaultMediaProvider<TMediaProvider extends IMediaProvider>(): TMediaProvider;
    resolveCacheInstance<TCacheInstance extends ICacheInstance>(name: string): TCacheInstance;
    resolveCacheInstances<TCacheInstance extends ICacheInstance>(): TCacheInstance[];
    registerCacheInstance<TCacheInstance extends ICacheInstance>(name: string, instance: TCacheInstance): this;
    resolveBucketProviders<TBucketProvider extends IFileProvider>(): TBucketProvider[];
    registerBucketProvider<TBucketProvider extends IBucketProvider>(name: string, instance: TBucketProvider): this;
    resolveSecretsProviders<TSecretsProvider extends ISecretsProvider>(): TSecretsProvider[];
    registerSecretsProvider<TSecretsProvider extends ISecretsProvider>(name: string, instance: TSecretsProvider): this;
    resolveAuthenticationMiddlewares<TAuthenticationMiddleware extends IAuthenticationMiddleware<any, unknown>>(): TAuthenticationMiddleware[];
    registerAuthenticationMiddleware<TAuthenticationMiddleware extends IAuthenticationMiddleware<any, unknown>>(name: string, instance: TAuthenticationMiddleware): this;
    resolveMediaReferenceRepository<TMediaReferenceRepository extends IMediaReferenceRepository>(): TMediaReferenceRepository;
    registerMediaReferenceRepository<TMediaReferenceRepository extends IMediaReferenceRepository>(instance: TMediaReferenceRepository): void;
    resolveMediaFolderRepository<TMediaFolderRepository extends IMediaFolderRepository>(): TMediaFolderRepository;
    registerMediaFolderRepository<TMediaFolderRepository extends IMediaFolderRepository>(instance: TMediaFolderRepository): void;
    resolveMediaProvider<TMediaProvider extends IMediaProvider>(providerId: string): TMediaProvider;
    registerMediaProvider<TMediaProvider extends IMediaProvider>(name: string, instance: TMediaProvider): this;
    resolveFileProvider<TFileProvider extends IFileProvider>(providerId: string): TFileProvider;
    registerFileProvider<TFileProvider extends IFileProvider>(name: string, instance: TFileProvider): this;
    resolveFilesReferenceRepositoryProviders<TFilesReferenceRepo extends IFilesReferenceRepository>(): TFilesReferenceRepo;
    registerFilesReferenceRepositoryProviders<TFilesReferenceRepo extends IFilesReferenceRepository>(instance: TFilesReferenceRepo): void;
    resolveEventsTracker<TEventsTracker extends IEventsTracker<TEventLog>, TEventLog extends IEventLog<unknown>>(): TEventsTracker;
    registerEventsTracker<TEventsTracker extends IEventsTracker<TEventLog>, TEventLog extends IEventLog<unknown>>(instance: TEventsTracker): void;
    resolveOperationLockService(): IOperationLockService;
    registerOperationLockService(instance: IOperationLockService): void;
    resolveEmailTemplatesCollection(): IEmailTemplatesCollection;
    registerEmailTemplatesCollection(instance: IEmailTemplatesCollection): void;
    resolveEmailTemplateMiddleware(): IEmailTemplateMiddleware | undefined;
    registerEmailTemplateMiddleware(instance: IEmailTemplateMiddleware): void;
    resolveEmailLogger(): IEmailLogger;
    registerEmailLogger(instance: IEmailLogger): void;
    resolvePipelinesController(): IPipelinesController;
    registerPipelinesController(instance: IPipelinesController): void;
    resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
    registerAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(instance: TAuthenticationContextProvider): void;
    resolveEntityConfiguration(entityName: string): IEntityConfiguration;
    registerEntityConfiguration(entityName: string, instance: IEntityConfiguration): void;
    resolveEntityManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
    registerEntityManager<TEntity>(entityName: string, instance: IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>): void;
    resolveEntityActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
    registerEntityActions<TEntity>(entityName: string, instance: IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>): void;
    resolveRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(entityName: string): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
    registerRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(entityName: string, instance: IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>): void;
    resolveEventsManager<TEntity, TEntityId>(entityName: string): IEntityEventsManager<TEntity, TEntityId>;
    registerEventsManager<TEntity, TEntityId>(entityName: string, instance: IEntityEventsManager<TEntity, TEntityId>): void;
    resolveReplicaSyncManager<TEntity>(entityName: string): IEntityReplicaSyncManager<TEntity>;
    registerReplicaSyncManager<TEntity>(entityName: string, instance: IEntityReplicaSyncManager<TEntity>): void;
    resolveReplicaConfiguration<TEntity, TEntityId>(entityName: string): IReplicasConfiguration<TEntity, TEntityId>;
    registerReplicaConfiguration<TEntity, TEntityId>(entityName: string, instance: IReplicasConfiguration<TEntity, TEntityId>): void;
    resolveReplicaDeleteManager<TEntity, TEntityId>(entityName: string): IEntityReplicaDeleteManager<TEntity, TEntityId>;
    registerReplicaDeleteManager<TEntity, TEntityId>(entityName: string, instance: IEntityReplicaDeleteManager<TEntity, TEntityId>): void;
    resolveConnectorSyncManager<TEntity>(entityName: string): IEntityConnectorSyncManager<TEntity>;
    registerConnectorSyncManager<TEntity>(entityName: string, instance: IEntityConnectorSyncManager<TEntity>): void;
    resolveConnectorDeleteManager<TEntity, TEntityId>(entityName: string): IEntityConnectorDeleteManager<TEntity, TEntityId>;
    registerConnectorDeleteManager<TEntity, TEntityId>(entityName: string, instance: IEntityConnectorDeleteManager<TEntity, TEntityId>): void;
    resolveConnectorsConfiguration<TEntity>(entityName: string): IConnectorsConfiguration<TEntity>;
    registerConnectorsConfiguration<TEntity>(entityName: string, instance: IConnectorsConfiguration<TEntity>): void;
    registerAdapter<TEntity, TEntityCreateData, TEntityUpdateData>(entityName: string, instance: IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>): void;
    resolveAdapter<TEntity, TEntityCreateData, TEntityUpdateData>(entityName: string): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
    registerConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(entityName: string, instance: IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>): void;
    resolveConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(entityName: string): IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
    registerSerializer<TEntity, TEntityId>(entityName: string, instance: IEntitySerializer<TEntity, TEntityId, unknown, unknown>): void;
    resolveSerializer<TEntity, TEntityId>(entityName: string): IEntitySerializer<TEntity, TEntityId, unknown, unknown>;
    registerSnapshotService<TEntity, TEntityId>(entityName: string, instance: IEntitySnapshotService<TEntityId, unknown>): void;
    resolveSnapshotService<TEntity, TEntityId>(entityName: string): IEntitySnapshotService<TEntityId, unknown> | undefined;
    resolveAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
    registerAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>): void;
    resolveGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
    registerGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>): void;
    resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
    registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string, instance: IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
    resolveFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    registerFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string, instance: IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>): void;
    resolveExistsQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityExistsQuery<TEntity, TEntityFilters>;
    registerExistsQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityExistsQuery<TEntity, TEntityFilters>): void;
    resolveCountQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntitiesCountQuery<TEntity, TEntityFilters>;
    registerCountQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntitiesCountQuery<TEntity, TEntityFilters>): void;
    resolveVersionsSearchQuery<TEntity, TCursor>(entityName: string): IEntityVersionsSearchQuery<TEntity, TCursor>;
    registerVersionsSearchQuery<TEntity, TCursor>(entityName: string, instance: IEntityVersionsSearchQuery<TEntity, TCursor>): void;
    resolveCreateCommand<TEntity, TEntityId, TEntityCreateData>(entityName: string): IEntityCreateCommand<TEntity, TEntityId, TEntityCreateData>;
    registerCreateCommand<TEntity, TEntityId, TEntityCreateData>(entityName: string, instance: IEntityCreateCommand<TEntity, TEntityId, TEntityCreateData>): void;
    resolveUpdateCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
    registerUpdateCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string, instance: IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>): void;
    resolveUpsertCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
    registerUpsertCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string, instance: IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>): void;
    registerUpsertByCommand<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityUpsertByCommand<TEntity, TEntityFilters>): void;
    resolveUpsertByCommand<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityUpsertByCommand<TEntity, TEntityFilters>;
    resolveDeleteItemsCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
    registerDeleteItemsCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string, instance: IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>): void;
    resolveDeleteCommand<TEntity, TEntityId>(entityName: string): IEntityDeleteCommand<TEntity, TEntityId>;
    registerDeleteCommand<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteCommand<TEntity, TEntityId>): void;
    resolveVersionCommand<TEntity, TEntityId>(entityName: string): IEntityVersionCommand<TEntity, TEntityId>;
    registerVersionCommand<TEntity, TEntityId>(entityName: string, instance: IEntityVersionCommand<TEntity, TEntityId>): void;
    resolveExportCommand<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string): IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    registerExportCommand<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string, instance: IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>): void;
    resolveImportCommand<TEntity>(entityName: string): IEntitiesImportCommand<TEntity>;
    registerImportCommand<TEntity>(entityName: string, instance: IEntitiesImportCommand<TEntity>): void;
    resolveParseCommand<TEntity>(entityName: string): IEntitiesParseCommand<TEntity>;
    registerParseCommand<TEntity>(entityName: string, instance: IEntitiesParseCommand<TEntity>): void;
    resolveSampleDownloadCommand<TEntity>(entityName: string): IEntitiesSampleDownloadCommand<TEntity>;
    registerSampleDownloadCommand<TEntity>(entityName: string, instance: IEntitiesSampleDownloadCommand<TEntity>): void;
    resolveGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
    registerGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string, instance: IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>): void;
    resolveExistsAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityExistsAction<TEntity, TEntityFilters>;
    registerExistsAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityExistsAction<TEntity, TEntityFilters>): void;
    resolveCountAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntitiesCountAction<TEntity, TEntityFilters>;
    registerCountAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntitiesCountAction<TEntity, TEntityFilters>): void;
    resolveSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
    registerSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string, instance: IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>): void;
    resolveVersionsSearchAction<TEntity, TEntityListItemDto, TCursor>(entityName: string): IEntityVersionsSearchAction<TEntity, TEntityListItemDto, TCursor>;
    registerVersionsSearchAction<TEntity, TEntityListItemDto, TCursor>(entityName: string, instance: IEntityVersionsSearchAction<TEntity, TEntityListItemDto, TCursor>): void;
    resolveCreateAction<TEntity, TEntityCreateData, TEntityDto>(entityName: string): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
    registerCreateAction<TEntity, TEntityCreateData, TEntityDto>(entityName: string, instance: IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>): void;
    resolveUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
    registerUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string, instance: IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>): void;
    resolveUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
    registerUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string, instance: IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>): void;
    resolveDeleteAction<TEntity, TEntityId>(entityName: string): IEntityDeleteAction<TEntity, TEntityId>;
    registerDeleteAction<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteAction<TEntity, TEntityId>): void;
    resolveDeleteItemsAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
    registerDeleteItemsAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string, instance: IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>): void;
    resolveExportAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string): IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    registerExportAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string, instance: IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor>): void;
    resolveSampleDownloadAction<TEntity>(entityName: string): IEntitiesSampleDownloadAction<TEntity>;
    registerSampleDownloadAction<TEntity>(entityName: string, instance: IEntitiesSampleDownloadAction<TEntity>): void;
    resolveImportAction<TEntity>(entityName: string): IEntitiesImportAction<TEntity>;
    registerImportAction<TEntity>(entityName: string, instance: IEntitiesImportAction<TEntity>): void;
    resolveParseAction<TEntity>(entityName: string): IEntitiesParseAction<TEntity>;
    registerParseAction<TEntity>(entityName: string, instance: IEntitiesParseAction<TEntity>): void;
    resolveQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
    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;
}

declare class EntityServiceLocator<TEntity, TEntityId> {
    private readonly services;
    private readonly entityName;
    constructor(services: EntitiesServiceLocator, entityName: string);
    getRootServices(): EntitiesServiceLocator;
    resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
    resolveEntityManager(): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
    resolveEntityActions(): IEntityActions<TEntity, TEntityId, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
    resolveRepository<TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
    resolveEventsManager(): IEntityEventsManager<TEntity, TEntityId>;
    resolveVersioningProvider(): IEntityVersioningProvider;
    resolveEntityConfiguration(): IEntityConfiguration;
    resolveReplicaSyncManager(): IEntityReplicaSyncManager<TEntity>;
    resolveReplicaConfiguration(): IReplicasConfiguration<TEntity, TEntityId>;
    resolveReplicaDeleteManager<TEntityId>(): IEntityReplicaDeleteManager<TEntity, TEntityId>;
    resolveConnectorSyncManager(): IEntityConnectorSyncManager<TEntity>;
    resolveConnectorDeleteManager<TEntityId>(): IEntityConnectorDeleteManager<TEntity, TEntityId>;
    resolveConnectorsConfiguration(): IConnectorsConfiguration<TEntity>;
    resolveConverter<TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(): IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
    resolveSerializer(): IEntitySerializer<TEntity, TEntityId, unknown, unknown>;
    resolveSnapshotService<TEntity, TEntityId>(): IEntitySnapshotService<TEntityId, unknown> | undefined;
    resolveAdapter<TEntityCreateData, TEntityUpdateData>(): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
    resolveAuthorizationMiddleware<TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
    resolveGetQuery<TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
    resolveExistsQuery<TEntityFilters extends ISearchFilters>(): IEntityExistsQuery<TEntity, TEntityFilters>;
    resolveCountQuery<TEntityFilters extends ISearchFilters>(): IEntitiesCountQuery<TEntity, TEntityFilters>;
    resolveVersionsSearchQuery<TCursor>(): IEntityVersionsSearchQuery<TEntity, TCursor>;
    resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
    resolveFindQuery<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    resolveCreateCommand<TEntityCreateData>(): IEntityCreateCommand<TEntity, TEntityId, TEntityCreateData>;
    resolveUpdateCommand<TEntityUpdateData>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
    resolveUpsertCommand<TEntityUpdateData>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
    resolveUpsertByCommand<TEntityFilters extends ISearchFilters>(): IEntityUpsertByCommand<TEntity, TEntityFilters>;
    resolveDeleteCommand<TEntityId>(): IEntityDeleteCommand<TEntity, TEntityId>;
    resolveDeleteItemsCommand<TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
    resolveVersionCommand(): IEntityVersionCommand<TEntity, TEntityId>;
    resolveSampleDownloadCommand(): IEntitiesSampleDownloadCommand<TEntity>;
    resolveImportCommand(): IEntitiesImportCommand<TEntity>;
    resolveParseCommand(): IEntitiesParseCommand<TEntity>;
    resolveExportCommand<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(): IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    resolveGetAction<TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
    resolveExistsAction<TEntityFilters extends ISearchFilters>(): IEntityExistsAction<TEntity, TEntityFilters>;
    resolveCountAction<TEntityFilters extends ISearchFilters>(): IEntitiesCountAction<TEntity, TEntityFilters>;
    resolveSearchAction<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
    resolveVersionsSearchAction<TEntityListItemDto, TCursor>(): IEntityVersionsSearchAction<TEntity, TEntityListItemDto, TCursor>;
    resolveCreateAction<TEntityCreateData, TEntityDto>(): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
    resolveUpdateAction<TEntityUpdateData, TEntityDto>(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
    resolveUpsertAction<TEntityUpdateData, TEntityDto>(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
    resolveDeleteAction(): IEntityDeleteAction<TEntity, TEntityId>;
    resolveDeleteItemsAction<TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
    resolveImportAction(): IEntitiesImportAction<TEntity>;
    resolveParseAction(): IEntitiesParseAction<TEntity>;
    resolveSampleDownloadAction(): IEntitiesSampleDownloadAction<TEntity>;
    resolveExportAction<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(): IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    resolveQueryBuilder<TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(): IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
    getEntityName(): string;
}

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;

interface GlobalAuthenticationMiddlewareProps {
    name: string;
    weight?: number;
}
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 CacheInstanceProps {
    instanceName: 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;
}
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;
}
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 extends ConnectorOptions {
    entityName: string;
    connectorName: string;
}
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 EntityConnectorMapperProps {
    entityName: string;
    connectorName: string;
}
declare const WpEntityConnectorMapper: (entityName: string, props: Omit<EntityConnectorMapperProps, "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;

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;
}
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;
interface EmailTemplateMiddlewareProps {
}
declare const WpEmailTemplateMiddleware: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

type EntityVersioningOptions = {
    enabled: boolean;
};
interface EntityProps {
    name: string;
    description?: 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 FileProviderProps {
    providerId: string;
}
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;

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;

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;

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;

interface MediaProviderProps {
    providerId: string;
}
declare const WpMediaProvider: (providerId: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
interface MediaReferenceRepositoryProps {
}
declare const WpMediaReferenceRepository: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
interface MediaFolderRepositoryProps {
}
declare const WpMediaFolderRepository: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

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;

type PipelineTemplateOptions$1 = {
    logging?: {
        enabled?: boolean;
        ignoreMeta?: boolean;
    };
};
type PipelineTemplateProps = {
    name: string;
    description?: string;
    concurrency?: PipelineConcurrency;
    options?: PipelineTemplateOptions$1;
};
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 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 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 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;
    EntityConnectorMapper: symbol;
    EntityConverter: symbol;
    EntitySerializer: symbol;
    EntitySnapshotService: symbol;
    EntityManager: symbol;
    EntityQueryBuilder: symbol;
    EntitySeeder: symbol;
    EntityVersioningProvider: symbol;
    EmailProvider: symbol;
    EmailTemplate: symbol;
    EmailLogger: symbol;
    EmailTemplateMiddleware: symbol;
    BucketProvider: symbol;
    MediaProvider: symbol;
    MediaReferenceRepository: symbol;
    MediaFolderRepository: symbol;
    SecretsProvider: symbol;
    FileProvider: symbol;
    FileReferenceRepository: symbol;
    PipelineTemplate: symbol;
    CacheInstance: symbol;
    OperationLockService: symbol;
};

declare enum TaskConcurrency {
    Single = "single",
    Multiple = "multiple"
}
type TaskSettings = {
    cronExpression?: string;
    concurrency: TaskConcurrency;
    description?: string;
    displayName?: string;
    hidden?: boolean;
};
type TaskProps = TaskSettings & {
    name: string;
};
declare function WpTask(name: string, settings: TaskSettings): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

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;

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;

interface IDiscoveryService {
    providersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
}

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;
}
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 implements IDiscoveryService {
    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;
}
/**
 * Exposes a query API over top of the NestJS Module container
 *
 * @export
 * @class DiscoveryModule
 */
declare class CustomDiscoveryModule {
}

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, connectors, connectorMappers, 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>;
        connectors?: DiscoveredClassWithMeta<EntityConnectorProps>[];
        connectorMappers?: DiscoveredClassWithMeta<EntityConnectorMapperProps>[];
        settings: EntityManagerSettings;
    }): Promise<void>;
    resolveEntityServicesCollection<TEntity>(entityName: string): EntityServiceLocator<TEntity, unknown>;
}

declare const buildProviderToken: (name: string) => string;

declare const EntityManagerProviderToken: {
    DiscoveryService: {};
    OperationsLockRepository: {};
    JobInstancesRepository: {};
    JobDefinitionsRepository: {};
};
declare const getEntityManagerProviderToken: (name: keyof typeof EntityManagerProviderToken) => string;

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;
}

type EntitySerializerOptions = {
    delimiter?: string;
};
declare abstract class EntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem, TContext, TPayload = unknown> implements IEntitySerializer<TEntity, TEntityId, TEntitySearchParameters, TSheetItem> {
    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
    protected readonly options?: EntitySerializerOptions | undefined;
    private readonly logger;
    protected readonly entityName: string;
    constructor(services: EntityServiceLocator<TEntity, TEntityId>, options?: EntitySerializerOptions | undefined);
    export(filters?: TEntitySearchParameters, payload?: TPayload): Promise<TSheetItem[]>;
    import(items: TSheetItem[], payload?: TPayload): Promise<void>;
    parse<TPayload>(data: Buffer, format: EntitySerializationFormat, payload?: TPayload): Promise<ImportEntry<TSheetItem, TEntityId>[]>;
    protected importItems(items: TSheetItem[], context: TContext, payload?: TPayload): Promise<void>;
    private parseCsv;
    private parseXlsx;
    private convertSheetRecord;
    private parseColumnValue;
    createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
    private buildSampleFile;
    serialize(data: TSheetItem[], format: EntitySerializationFormat, payload?: TPayload): Promise<EntityExportFile>;
    protected abstract getDefinition(context: TContext, payload?: TPayload): Promise<EntitySerializerSheetDefinition<TSheetItem>>;
    protected abstract loadEntities(filters?: TEntitySearchParameters): Promise<TEntity[]>;
    protected abstract convertToSheetItems(entities: TEntity[], payload?: TPayload): Promise<TSheetItem[]>;
    protected validateSheetItem(item: TSheetItem, allItems: TSheetItem[], context: TContext): void;
    protected abstract importItem(item: TSheetItem, context: TContext, payload?: TPayload): Promise<EntityReference<TEntityId>>;
    protected getContext(): Promise<TContext>;
    private buildExportFile;
    private getColumnValue;
    private selectColumnValue;
    private buildExportFileName;
}

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, options?: EntitySerializerOptions);
    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 IAuthTenant {
    id: string;
    uid: string;
    name: string;
}
interface IAuthOrganization {
    id: string;
    uid: string;
    name: string;
    tenant: IAuthTenant;
}
interface IAuthDirectory {
    id: string;
    uid: string;
    name: string;
}
interface IAuthApiKey {
    id: string;
    key: string;
    name: string;
    disabled: boolean;
    organization?: IAuthOrganization;
}
interface IAuthUser {
    id: string;
    passwordHash: string;
    passwordUpdateTimestamp?: Date;
    temporaryPassword: boolean;
    userName: string;
    email: string;
    verified: boolean;
    verifiedTimestamp?: Date;
    disabled: boolean;
    profile: IAuthUserProfile;
    organization?: IAuthOrganization;
    directory?: IAuthDirectory;
}
interface IAuthUserContext {
    organizationUid?: string;
    directoryUid?: 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>;
    isUserInRole(userId: string, roleId: string): Promise<boolean>;
}
interface IAuthApiKeysService<TAuthApiKey extends IAuthApiKey> {
    find(apiKey: string): Promise<TAuthApiKey | undefined>;
    create(data: {
        key: string;
        name: string;
        organizationId?: string;
    }): Promise<TAuthApiKey>;
    enable(id: string): Promise<void>;
    disable(id: string): Promise<void>;
    delete(id: string): Promise<void>;
}

type CurrentUserData = {
    user: IAuthUser;
    roles: IAuthRole[];
    permissions: IAuthPermission[];
    organizationalUnits: IAuthOrganizationalUnit[];
};
declare const CurrentUser: (...dataOrPipes: unknown[]) => ParameterDecorator;

interface AuthenticationModuleSettings {
    passwordSalt: string;
    jwtSecret: string;
}
type UserPasswordResetTokenPayload = {
    userId: string;
    email: string;
    timestamp: number;
};
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;
};

type ApiKeyRouteOptions = {
    strict?: 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 ApiKeyAccess: (options?: ApiKeyRouteOptions) => _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: {
    ApiKeysService: symbol;
    UserRolesService: symbol;
    UserService: symbol;
    PermissionsService: symbol;
    RolesService: 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 WpApiKeysService: () => <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 = {
    firstName: string;
    lastName: string;
    callbackUrl: string;
};

declare class AuthenticationError extends Error {
    constructor(message: string);
}
declare class InvalidCredentialsError extends AuthenticationError {
    constructor(message: string);
}
declare class OperationTokenMismatchError extends AuthenticationError {
    constructor(message: string);
}

declare const AUTHENTICATION_EVENTS_NAMESPACE = "authentication";
declare const AuthenticationEvents: {
    UserLogin: string;
    UserRegistrationStarted: string;
    UserRegistrationCompleted: string;
    UserPasswordResetStarted: string;
    UserPasswordResetCompleted: string;
};

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 AuthGuard implements CanActivate {
    private reflector;
    private readonly logger;
    constructor(reflector: Reflector);
    canActivate(context: ExecutionContext): boolean;
    private isRoleMatching;
    private isPermissionMatching;
    private getIsForAllAuthenticated;
    private getIsPublic;
    private getApiRoute;
    private getAllowedRoles;
    private getAllowedPermissions;
    private getCurrentAuth;
    private getMetadata;
    private getContextInfo;
}

declare enum UserCreationError {
    UserAlreadyExists = "userAlreadyExists"
}
type UserCreationInput<TUserRegistrationInfo, TUserContext extends IAuthUserContext> = {
    email: string;
    userName: string;
    /**
     * Password for the user account.
     * - Required for standard email/password authentication
     * - Should be omitted (undefined) when using passwordless OAuth login
     */
    password?: string;
    registrationInfo: TUserRegistrationInfo;
    context?: TUserContext;
    verified?: boolean;
};
type UserCreationResult = {
    success: boolean;
    error?: UserCreationError;
    userId?: string;
};

type UserDisableInput = {
    userId: string;
};

type UserDeleteInput = {
    userId: string;
};

type UserEnableInput = {
    userId: string;
};

type UserLoginInput<TUserContext extends IAuthUserContext> = {
    userName: string;
    password: string;
    context?: TUserContext;
};
type UserLoginResult = {
    token?: string;
    userId?: string;
    success: boolean;
};

type UserPasswordChangeInput = {
    userId: string;
    newPassword: string;
    temporary: boolean;
};

type UserPasswordResetCompleteInput<TUserContext extends IAuthUserContext> = {
    token: string;
    newPassword: string;
    temporary?: boolean;
    context?: TUserContext;
};

type UserPasswordResetRequestCallbackTemplate = {
    urlTemplate: string;
    tokenPlaceholder: string;
};
type UserPasswordResetRequestInput<TUserContext extends IAuthUserContext> = {
    email: string;
    callback: UserPasswordResetRequestCallbackTemplate;
    languageCode: string;
    context?: TUserContext;
    emailTemplateId?: string;
};
type UserPasswordResetRequestResult = {
    success: boolean;
};

type UserRegisterCallbackTemplate = {
    urlTemplate: string;
    tokenPlaceholder: string;
};
type UserRegistrationInput<TUserRegistrationInfo, TUserContext extends IAuthUserContext> = {
    email: string;
    userName: string;
    password: string;
    registrationInfo: TUserRegistrationInfo;
    callback?: UserRegisterCallbackTemplate;
    languageCode: string;
    context?: TUserContext;
};
type UserRegistrationResult = {
    success: boolean;
    error?: UserRegistrationError;
    userId?: string;
};

type UserTokenVerifyResult<TUserContext extends IAuthUserContext> = {
    isValid: boolean;
    data: IAuthUserTokenData<TUserContext>;
};
type UserTokenVerifyInput = {
    token: string;
};

type UserVerifyCompleteInput<TUserContext extends IAuthUserContext> = {
    token: string;
    context?: TUserContext;
};

type UserVerifyRequestInput<TUserContext extends IAuthUserContext> = {
    email: string;
    callback: UserVerifyRequestCallbackTemplate;
    languageCode: string;
    context?: TUserContext;
    emailTemplateId?: string;
};
type UserVerifyRequestResult = {
    success: boolean;
};
type UserVerifyRequestCallbackTemplate = {
    urlTemplate: string;
    tokenPlaceholder: string;
};

interface IAppSessionService<TRequest> {
    getValue<T>(key: string): T;
    setValue<T>(key: string, value: T): void;
    clearValue(key: string): void;
    getRequest(): TRequest;
    retrieveRequest(): TRequest;
}

declare class AppSessionService implements IAppSessionService<unknown> {
    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 class AppHashingService {
    hash(value: string, salt: string): Promise<string>;
    compare(hash: string, value: string, salt: string): Promise<boolean>;
}

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 class MediaLibraryService implements IMediaLibraryManager {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    mediaUpload(input: MediaUploadInput): Promise<MediaItemReference>;
    mediaDelete(input: MediaReference): Promise<void>;
    mediaDownload(input: MediaReference): Promise<Buffer>;
    folderEnsure(input: MediaFolderEnsureInput): Promise<MediaFolderReference>;
    folderCreate(input: MediaFolderCreateInput): Promise<MediaFolderReference>;
    folderMove(input: MediaFolderMoveInput): Promise<void>;
    folderRename(input: MediaFolderRenameInput): Promise<void>;
    folderDelete(input: MediaFolderReference): Promise<void>;
    foldersList(parent?: MediaFolderReference | undefined): Promise<MediaFolderReference[]>;
    getFolderMedia(input: MediaFolderReference): Promise<MediaInfo[]>;
    private parseReferenceProviderId;
    private getMediaProvider;
    private get defaultMediaProvider();
    private get mediaFolderRepository();
    private get mediaReferenceRepository();
}

declare class OperationLockService implements IOperationLockService {
    private readonly operations;
    constructor(operations: ILockRepository);
    executeSequential: <T>(input: ExecuteSequentialInput<T>) => Promise<T>;
    executeExclusive: <T>(input: ExecuteExclusiveInput<T>) => Promise<ExclusiveOperationResult<T>>;
    private isLockExpired;
}

declare class LockItemClass {
    uid: string;
    lockedBy?: string;
    createdOn: Date;
}
declare class TypeormOperationLockRepository<TLockEntry extends LockItemClass> implements ILockRepository {
    private readonly repo;
    private readonly entityClass;
    constructor(repo: Repository<TLockEntry>, entityClass: EntityTarget<TLockEntry>);
    getLock: (lockUid: string) => Promise<TLockEntry | undefined>;
    acquireLock: (input: LockAcquireInput) => Promise<LockAcquireResult>;
    releaseLock: (input: LockReleaseInput) => Promise<void>;
}

declare class EmailService {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    sendTemplatedEmail<TPayload>(input: TemplatedEmailInput<TPayload>, options?: EmailSendOptions): Promise<void>;
    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>, options?: EmailSendOptions): Promise<void>;
    private getTemplate;
    private hasRecipients;
    private get templateMiddleware();
    private get templates();
    private get provider();
    private get logger();
}

type DataExportInput<TSheetItem> = {
    dataName: string;
    fileName: string;
    columns: DataSerializerColumnDefinition<TSheetItem>[];
    format: DataSerializationFormat;
};
type DataSerializerColumnDefinition<TSheetItem> = {
    name: string;
    key: string;
    selector: keyof TSheetItem | ((item: TSheetItem) => any);
    colSpan?: number;
    array?: boolean;
    arraySeparator?: string;
};
type DataExportFile = {
    content: Buffer;
    contentType: string;
};
declare enum DataSerializationFormat {
    Csv = "csv",
    Json = "json",
    Xlsx = "xlsx"
}

declare class DataExportService {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    exportData<TSheetItem>(data: TSheetItem[], input: DataExportInput<TSheetItem>): Promise<{
        downloadUrl: FileProviderDownloadUrl;
        file: {
            fileName: string;
            content: Buffer;
            contentType: string;
        };
    }>;
    extractData<TSheetItem>(data: TSheetItem[], input: Omit<DataExportInput<TSheetItem>, "fileName">): Promise<DataExportFile>;
    private uploadExportFile;
    private buildExportFileName;
    private buildExportFilePath;
    private get defaultFileProvider();
    private get defaultBucketProvider();
}

type DataSheet<T> = {
    name: string;
    data: T[];
    columns: DataSerializerColumnDefinition<T>[];
};
declare class DataSheetsBuilder {
    private sheets;
    addSheet<T>(sheet: DataSheet<T>): void;
    build(): Promise<DataExportFile>;
}
declare class DataSheetsExporterService {
    createBuilder(): DataSheetsBuilder;
}

declare class CacheService {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    getInstance(instanceName: string): ICacheInstance;
    getInstances(): ICacheInstance[];
}

declare class FilesManager implements IFileManager {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    uploadFile(file: FileData): Promise<FileReference>;
    removeFile(fileId: string): Promise<void>;
    getFileContent(fileId: string): Promise<FileData>;
    getFileDownloadUrl(fileId: string): Promise<FileDownloadUrl>;
    getFileReferenceDownloadUrl({ reference, providerId, }: {
        reference: string;
        providerId: string;
    }): Promise<FileDownloadUrl>;
    private getFileProvider;
    private get defaultFileProvider();
    private get referencesRepo();
}

type IEventData<TEventPayload> = {
    payload?: TEventPayload;
    userId?: string;
    userName?: string;
    timestamp?: Date;
};
declare class EventsService {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    emitEvent<TEventPayload>(eventName: string, eventData: IEventData<TEventPayload>): Promise<void>;
    private buildPayload;
    private get eventEmitter();
}

declare class TrackingService {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    trackEvent<T>(event: IEventLog<T>): Promise<void>;
    private get tracker();
}

declare class SecretsService {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    get secretsProvider(): ISecretsProvider;
    private get providers();
}

declare class AuthenticationServicesResolver {
    private usersService;
    private rolesService;
    private permissionsService;
    private usersRolesService;
    private apiKeysService;
    registerApiKeysService(service: IAuthApiKeysService<any>): void;
    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;
    getApiKeysService(): IAuthApiKeysService<any>;
    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 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 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 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 UserDisableHandler {
    private readonly services;
    constructor(services: AuthenticationServicesResolver);
    execute(input: UserDisableInput): Promise<void>;
}

declare class UserEnableHandler {
    private readonly services;
    constructor(services: AuthenticationServicesResolver);
    execute(input: UserEnableInput): Promise<void>;
}

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 UserPasswordChangeHandler {
    private readonly services;
    private readonly passwordHashingProvider;
    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider);
    execute(input: UserPasswordChangeInput): Promise<void>;
}

declare class UserPasswordResetCompleteHandler {
    private readonly services;
    private readonly passwordHashingProvider;
    private readonly jwtProvider;
    constructor(services: AuthenticationServicesResolver, passwordHashingProvider: PasswordHashingProvider, jwtProvider: JwtProvider);
    execute<TUserContext extends IAuthUserContext>(input: UserPasswordResetCompleteInput<TUserContext>): Promise<{
        userId: string;
        token: string;
    }>;
    private generateUserJwtToken;
    private decodeToken;
    private validateUser;
    private getUser;
}

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;
}

declare class UserVerifyCompleteHandler {
    private readonly services;
    private readonly jwtProvider;
    constructor(services: AuthenticationServicesResolver, jwtProvider: JwtProvider);
    execute<TUserContext extends IAuthUserContext>(input: UserVerifyCompleteInput<TUserContext>): Promise<{
        userId: string;
        token: string;
    }>;
    private generateUserJwtToken;
    private decodeToken;
    private validateUser;
    private getUser;
}

declare class UserTokenVerifyHandler {
    private readonly jwtProvider;
    constructor(jwtProvider: JwtProvider);
    execute<TUserContext extends IAuthUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
    private decodeUserJwtToken;
}

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;
}

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 class UserDeleteHandler {
    private readonly services;
    constructor(services: AuthenticationServicesResolver);
    execute(input: UserDeleteInput): Promise<void>;
}

type UserImpersonateInput<TUserContext extends IAuthUserContext> = {
    userName: string;
    context?: TUserContext;
};
type UserImpersonateResult = {
    token: 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;
}

type UserInvitationSendInput = {
    userId: string;
    callback: UserRegisterCallbackTemplate;
} & ({
    emailTemplateId: string;
    languageId: string;
} | {
    emailTemplateId?: undefined;
    languageId?: string;
});

declare class UserInvitationSendHandler {
    private readonly services;
    private readonly emailService;
    private readonly jwtProvider;
    constructor(services: AuthenticationServicesResolver, emailService: EmailService, jwtProvider: JwtProvider);
    execute(input: UserInvitationSendInput): Promise<{
        token: string;
        callbackUrl: string;
    }>;
    private sendRegistrationEmail;
    private generateEmailVerifyToken;
}

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 userInvitationHandler;
    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, userInvitationHandler: UserInvitationSendHandler, resolver: AuthenticationServicesResolver);
    userCreate<TUserRegistrationInfo, TUserContext extends IAuthUserContext>(input: UserCreationInput<TUserRegistrationInfo, TUserContext>): Promise<UserCreationResult>;
    userInvite(input: UserInvitationSendInput): Promise<{
        token: string;
        callbackUrl: string;
    }>;
    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<TUserContext extends IAuthUserContext>(input: UserPasswordResetCompleteInput<TUserContext>): Promise<{
        userId: string;
        token: string;
    }>;
    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<TUserContext extends IAuthUserContext>(input: UserVerifyCompleteInput<TUserContext>): Promise<{
        userId: string;
        token: string;
    }>;
    userTokenVerify<TUserContext extends IAuthUserContext>(input: UserTokenVerifyInput): Promise<UserTokenVerifyResult<TUserContext>>;
    get apiKeysService(): IAuthApiKeysService<any>;
    get usersService(): IAuthUserService<IAuthUser, any, unknown>;
    get rolesService(): IAuthRoleService<IAuthRole, IAuthPermission>;
    get userRolesService(): IAuthUserRolesService<IAuthUser, IAuthRole, IAuthPermission, IAuthOrganizationalUnit>;
}

declare class AuthenticationModule implements NestModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AuthenticationModuleSettings): DynamicModule;
    static initialize(input: AuthenticationModuleSettings): void;
    configure(consumer: MiddlewareConsumer): void;
}

interface IAppDirectory {
    id: string;
    uid: string;
    name: string;
}
interface IAppTenant {
    id: string;
    uid: string;
    name: string;
}
interface IAppOrganization {
    id: string;
    uid: string;
    name: string;
    tenant: IAppTenant;
}
interface IAppCompany {
    id: string;
    uid: string;
    name: string;
    organization: IAppOrganization;
}
interface IAppDivision {
    id: string;
    uid: string;
    name: string;
    company: IAppCompany;
}
interface IAppUserProfile {
    firstName: string;
    lastName: 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;
}

interface IMultiTenantEntity {
    tenant: IAppTenant;
}
interface IMultiOrganizationEntity {
    organization: IAppOrganization;
}
interface IMultiCompanyEntity {
    company: IAppCompany;
}

declare class MultiTenancyModule {
}

declare enum JobConcurrency {
    Sequential = "sequential",
    Parallel = "parallel"
}
declare class JobSchedule<TInvocationParams> {
    uid: string;
    cron: string;
    enabled: boolean;
    invocationOverrides?: TInvocationParams;
}
type JobDefinition<TInfrastructureParams, TInvocationParams> = {
    id: string;
    uid: string;
    name: string;
    provider: string;
    infrastructureParams: TInfrastructureParams;
    invocationParams: TInvocationParams;
    schedules: JobSchedule<TInvocationParams>[];
    concurrency: JobConcurrency;
};

declare enum JobStatus {
    Created = "created",
    Ready = "ready",
    Initializing = "initializing",
    Running = "running",
    Completed = "completed",
    Faulted = "faulted",
    InitializationError = "initializationError"
}
declare enum JobRunType {
    Scheduled = "scheduled",
    OnDemand = "onDemand"
}
declare class JobInstance {
    id: string;
    scheduleUid?: string;
    jobUid: string;
    runType: JobRunType;
    status: JobStatus;
    insertTime?: Date;
    startTime?: Date;
    endTime?: Date;
    result?: any;
    error?: any;
    createdOn?: Date;
    updatedOn?: Date;
}

declare enum JobProviderState$1 {
    Initializing = "initializing",
    Running = "running",
    Completed = "completed",
    CompletedWithErrors = "completedWithErrors"
}

type JobData = Omit<JobDefinition<unknown, unknown>, "id" | "createdOn" | "updatedOn">;
interface IJobDefinitionsRepository {
    getAllDefinitions(): Promise<JobDefinition<unknown, unknown>[]>;
    getDefinitionByUid(uid: string): Promise<JobDefinition<unknown, unknown> | undefined>;
    ensureDefinition(data: JobData): Promise<JobDefinition<unknown, unknown>>;
    createDefinition(data: JobData): Promise<JobDefinition<unknown, unknown>>;
    updateDefinition(uid: string, data: JobData): Promise<JobDefinition<unknown, unknown>>;
}
interface IJobInstancesRepository {
    getById(id: string): Promise<JobInstance>;
    getByStatus(...status: JobStatus[]): Promise<JobInstance[]>;
    getLastInstance(jobUid: string, scheduleUid?: string): Promise<JobInstance | undefined>;
    appendInstance(job: JobDefinition<unknown, unknown>, data: Pick<JobInstance, "id" | "insertTime" | "scheduleUid" | "runType">): Promise<JobInstance>;
    updateInstance(instanceId: string, data: Pick<JobInstance, "startTime" | "endTime" | "status" | "result" | "error">): Promise<JobInstance>;
}

type JobsSettings = {
    scheduler: {
        enabled: boolean;
        intervalSeconds: number;
    };
    monitor: {
        enabled: boolean;
        intervalSeconds: number;
    };
};

declare class RunnableJobsProcessor {
    private readonly jobInstances;
    private readonly logger;
    constructor(jobInstances: IJobInstancesRepository);
    shouldRun(job: JobDefinition<unknown, unknown>, schedule: JobSchedule<unknown>): Promise<boolean>;
}

declare class JobsSchedulerTask {
    private readonly jobDefinitions;
    private readonly evaluator;
    private readonly commandBus;
    private readonly logger;
    constructor(jobDefinitions: IJobDefinitionsRepository, evaluator: RunnableJobsProcessor, commandBus: CommandBus);
    run(): Promise<void>;
    private evaluateJob;
    private evaluateJobSchedule;
}

declare class JobsMonitorTask {
    private readonly jobInstances;
    private readonly jobDefinitions;
    private readonly commandBus;
    private readonly logger;
    constructor(jobInstances: IJobInstancesRepository, jobDefinitions: IJobDefinitionsRepository, commandBus: CommandBus);
    run(): Promise<void>;
    private monitorInstance;
}

declare class JobsScheduler {
    private readonly schedulerRegistry;
    private readonly schedulerTask;
    private readonly monitorTask;
    private readonly logger;
    constructor(schedulerRegistry: SchedulerRegistry, schedulerTask: JobsSchedulerTask, monitorTask: JobsMonitorTask);
    register(): void;
    private registerJobsScheduler;
    private registerJobsMonitor;
    private batchJobsSchedule;
    private batchJobsMonitor;
    private get jobsSettings();
}

type AwsJobComputePlatformType = "ec2" | "fargate";
type AwsJobEnvironmentVariable = {
    name: string;
    value: string;
};
type AwsBatchInfrastructureParams = {
    vcpu: number;
    memory: number;
    gpu?: number;
    ephemeralStorageGB?: number;
    dockerImage: string;
    environmentVariables?: AwsJobEnvironmentVariable[];
    computePlatformType?: AwsJobComputePlatformType;
    assignPublicIp?: boolean;
    logGroupName?: string;
    privileged?: boolean;
    batchComputeEnvironment?: string;
};
type AwsBatchInvocationParams = {
    startCommand: string[];
};
type AwsJobDefinition = JobDefinition<AwsBatchInfrastructureParams, AwsBatchInvocationParams>;

type BatchJobVariables = Record<string, string>;

interface JobDispatchInput {
    definition: JobDefinition<unknown, unknown>;
    schedule?: JobSchedule<unknown>;
    instanceId: string;
    payload?: unknown;
    commandPlaceholders?: Record<string, string>;
    variables?: BatchJobVariables;
}
declare enum JobProviderState {
    Initializing = "initializing",
    Running = "running",
    Completed = "completed",
    CompletedWithErrors = "completedWithErrors"
}
interface GetJobStatusInput {
    definition: JobDefinition<unknown, unknown>;
    instanceId: string;
}
interface JobStatusResult {
    state: JobProviderState;
    error?: string;
}
interface CancelJobStatusInput {
    instanceId: string;
}
interface UpsertJobDefinitionInput {
    definition: JobDefinition<unknown, unknown>;
}
interface JobProviderInstance {
    dispatch(input: JobDispatchInput): Promise<void>;
    upsertJobDefinition(input: UpsertJobDefinitionInput): Promise<void>;
    getJobStatus(input: GetJobStatusInput): Promise<JobStatusResult>;
    cancelJob(input: CancelJobStatusInput): Promise<void>;
}

declare class JobsProviderFactory {
    private readonly discover;
    private readonly logger;
    private providers;
    constructor(discover: CustomDiscoveryService);
    initialize(): Promise<void>;
    getProvider(id: string): JobProviderInstance;
}

declare class JobsModule implements OnModuleInit {
    private readonly jobsScheduler;
    private readonly jobsProviderFactory;
    constructor(jobsScheduler: JobsScheduler, jobsProviderFactory: JobsProviderFactory);
    onModuleInit(): Promise<void>;
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: JobsSettings): DynamicModule;
    static initialize(input: JobsSettings): void;
}

type JobTriggerInput = {
    jobUid: string;
    scheduleUid?: string;
    payload?: any;
    commandPlaceholders?: Record<string, string>;
    variables?: BatchJobVariables;
};

declare class JobsService {
    private readonly definitions;
    private readonly instances;
    private readonly commandBus;
    constructor(definitions: IJobDefinitionsRepository, instances: IJobInstancesRepository, commandBus: CommandBus);
    triggerJob: (input: JobTriggerInput) => Promise<JobInstance>;
    updateJob: (input: JobDefinition<unknown, unknown>) => Promise<void>;
    instanceMonitor: (input: {
        instanceId: string;
    }) => Promise<any>;
}

declare enum TaskRunType {
    Scheduled = "Scheduled",
    OnDemand = "OnDemand"
}
type TaskContext = {
    name: string;
    runId: string;
    runType: TaskRunType;
    startedAt: Date;
};
interface ITask {
    execute(context: TaskContext): Promise<void>;
}

declare class TaskShell {
    private readonly registry;
    private readonly operations;
    private readonly logger;
    constructor(registry: EntityManagerRegistry, operations: ILockRepository);
    executeTask(instance: ITask, settings: TaskProps, runType: TaskRunType): Promise<void>;
    private executeTaskParallel;
    private executeTaskSequential;
    private getTaskLockKey;
    private invokeTask;
    private get operationsLockService();
}

declare class TaskScheduler {
    private schedulerRegistry;
    private readonly jobShell;
    private readonly logger;
    private readonly cronJobs;
    constructor(schedulerRegistry: SchedulerRegistry, jobShell: TaskShell);
    scheduleTask(job: TaskProps, instance: ITask): Promise<void>;
    stopAllTasks(): void;
}

declare class AppInMemorySettings<T> {
    private readonly name;
    private _instance;
    constructor(name: string);
    initialize(value: T): void;
    get value(): T;
}

type TasksModuleSettings = {
    enabled?: boolean;
};

declare class TasksModule implements OnModuleDestroy {
    private readonly scheduler;
    constructor(scheduler: TaskScheduler);
    static initialize(input: TasksModuleSettings): void;
    onModuleDestroy(): void;
}

declare class TasksRegistry {
    private readonly tasks;
    registerTask(props: TaskProps, instance: ITask): void;
    getTask(name: string): {
        props: TaskProps;
        instance: ITask;
    };
    getTasks(): {
        props: TaskProps;
        instance: ITask;
    }[];
}

declare class TasksService {
    private readonly jobShell;
    private readonly registry;
    private readonly logger;
    constructor(jobShell: TaskShell, registry: TasksRegistry);
    triggerTask(name: string): Promise<void>;
    invokeTask(name: string): Promise<void>;
    getTasks(): Promise<{
        props: TaskProps;
        instance: ITask;
    }[]>;
}

declare const createExpressFileResponse: (res: Response, file: {
    content: Buffer;
    contentType: string;
    name: string;
}) => StreamableFile;

type DynamoDbCacheInstanceOptions = {
    tableName: string;
    partitionKey?: string;
    sortKey?: string;
};
declare abstract class DynamoDbCacheInstance implements ICacheInstance {
    protected readonly instanceName: string;
    private readonly logger;
    private readonly collection;
    constructor(instanceName: string, dynamoDbOptions: DynamoDbCacheInstanceOptions);
    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>;
    getInstanceName(): string;
    private isExpired;
}

type DynamoDbCacheItem = {
    instance: string;
    key: string;
    expiration: number;
    createdOn: number;
    updatedOn: number;
    data: any;
};

declare abstract class InMemoryCacheInstance implements ICacheInstance {
    protected readonly instanceName: string;
    private readonly store;
    constructor(instanceName: 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>;
    getInstanceName(): string;
    private isExpired;
    private toCacheEntryInfo;
    private toCacheEntryDetail;
}

type InMemoryCacheEntry = {
    key: string;
    data: unknown;
    createdOn: number;
    updatedOn: number;
    expiration: number;
};

interface ICacheDatabaseItem {
    id: string;
    instance: string;
    key: string;
    data: any;
    createdOn: Date;
    updatedOn: Date;
    expirationTime: Date;
}

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 class PipelineController implements IPipelinesController {
    createInstance<TInput, TOutput, TContext>(definition: PipelineDefinition<TInput, TOutput, TContext>, input: TInput, context: TContext): Promise<IPipelineInstance<TInput, TOutput, TContext>>;
}

declare enum QueryBuilderOperation {
    Search = "search",
    Get = "get"
}
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;
}

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[]>;
    findOne(condition: FindManyOptions<TEntity>): Promise<TEntity | undefined>;
    findOneOrFail(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>;
    upsertBy({ data, filter, }: {
        data: Partial<TEntity>;
        filter: FindManyOptions<TEntity>;
    }): Promise<EntityReference<string>>;
}

type NumericFilter = {
    in?: number[];
    eq?: number;
    gt?: number;
    gte?: number;
    lt?: number;
    lte?: number;
    isNull?: boolean;
    notIn?: number[];
};
type StringFilter = {
    gt?: string;
    gte?: string;
    lt?: string;
    lte?: string;
    in?: string[];
    ieq?: string;
    eq?: string;
    like?: string;
    ne?: string;
    ine?: string;
    notIn?: string[];
    notLike?: string;
    isNull?: boolean;
    isEmpty?: boolean;
};
type IdFilter = {
    in?: string[];
    eq?: string;
    ne?: string;
    notIn?: string[];
    isNull?: boolean;
};
type EnumFilter<T> = {
    in?: T[];
    eq?: T;
    ne?: T;
    notIn?: T[];
    isNull?: boolean;
};
type ArrayFilter<T> = {
    eq?: T[];
    isNull?: boolean;
};
type BooleanFilter = {
    eq?: boolean;
    ne?: boolean;
    isNull?: boolean;
    in?: boolean[];
    notIn?: boolean[];
};
type DateFilter = {
    in?: Date[];
    eq?: Date;
    gt?: Date;
    gte?: Date;
    lt?: Date;
    lte?: Date;
    isNull?: boolean;
};
type StringListFilter = {
    contains?: string;
    iContains?: string;
    notContains?: string;
    iNotContains?: string;
};

declare class QueryClauseBuilder {
    stringArrayFilter(filter: ArrayFilter<string>): FindOperator<string>;
    enumFilter<T>(filter: EnumFilter<T>): FindOperator<T>;
    idFilter(filter: IdFilter): FindOperator<string>;
    stringFilter(filter: StringFilter): FindOperator<string>;
    stringListFilter(filter: StringListFilter): FindOperator<string>;
    numericFilter(filter: NumericFilter): FindOperator<number>;
    dateFilter(filter: DateFilter): FindOperator<Date>;
    boolFilter(filter: BooleanFilter): FindOperator<boolean>;
    private buildInClause;
}

type FacetValueType<T> = {
    value: T;
    label: string;
    count: number;
};
type FacetType<T> = {
    values: FacetValueType<T>[];
};
type StringFacetsType = FacetType<string>;
type NumberFacetsType = FacetType<number>;
type BooleanFacetsType = FacetType<boolean>;
type DateFacetsType = FacetType<Date>;
type FacetRelations = {
    columns: string[];
};
type FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext> = {
    field: keyof TEntity;
    request: TEntitySearchParameters;
    context: IAuthenticationContext<TUserContext> | undefined;
    relations?: FacetRelations;
    labelSelector?: string;
};

type ChildrenMap = Record<string, {
    count: number;
}>;

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>, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): 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"];
        relations?: TEntitySearchParameters["relations"];
    }, 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 calculateStringFieldFacets(input: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<StringFacetsType>;
    protected calculateNumericFieldFacets(input: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<NumberFacetsType>;
    protected calculateBooleanFieldFacets(input: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<BooleanFacetsType>;
    protected calculateFacet<TValue>({ field, request, context, relations, labelSelector, }: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<FacetType<TValue>>;
    protected getRepository(): TypeOrmRepository<TEntity, unknown>;
    private buildSearchRelations;
    private buildWhere;
    private mergeWhereClauses;
    private mergeWheres;
}

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);
}

declare class NestTypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> extends TypeOrmRepository<TEntity, TEntityId> {
    constructor(repository: Repository<TEntity>);
}

interface IEntitySeedEntry<TEntity, TFindCondition> {
    identifier: TFindCondition;
    data: () => Partial<TEntity>;
}
interface IEntitySeeder {
    execute(): Promise<void>;
    get priority(): number | undefined;
}

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 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 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 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 EntityParseValidationColumn {
    name: string;
    key: string;
}
declare class EntityParseValidationError {
    errorCode: string;
    column: EntityParseValidationColumn;
}
declare class EntityParseStatus {
    isValid: boolean;
    validationErrors: EntityParseValidationError[];
}
declare class EntityParseResult {
    rowIndex: number;
    item: any;
    status: EntityParseStatus;
}

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 IPipelineTemplateBuilder<TPipelineInput, TContext> {
    addStep<TStepOutput>(builder: (step: IPipelineStepOperationBuilder<TPipelineInput, TStepOutput, TPipelineInput, TContext>) => void): IPipelineStepBuilder<TPipelineInput, TStepOutput, TPipelineInput, TContext>;
}

declare class PipelinesBuilder {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    createTemplate<TInput, TContext>(): IPipelineTemplateBuilder<TInput, TContext>;
}

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();
}

declare class PipelineUtils<TPipelineInput, TPipelineOutput, TContext> {
    getStepByKey: (state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
    getStepInputByKey: <TStepInput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => TStepInput;
    getStepOutputByKey: <TStepOutput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => TStepOutput;
    getStep: (state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
    getStepInput: <TStepInput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepInput;
    getStepOutput: <TStepOutput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepOutput;
}

type PipelineTemplateOptions = {
    concurrency?: PipelineConcurrency;
    logging?: {
        ignoreMeta?: boolean;
    };
};
declare abstract class NestPipelineTemplate<TPipelineInput, TPipelineOutput, TContext> {
    private readonly options?;
    constructor(options?: PipelineTemplateOptions | undefined);
    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;
    protected getConcurrencyKey(input: TPipelineInput): string;
    invoke(input: TPipelineInput): Promise<TPipelineOutput>;
    execute(data: {
        input: TPipelineInput;
        context: TContext;
    }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
    private pipelineExecute;
    private processLogMetadata;
    private getDefinition;
    private buildDefinition;
    private getContext;
    private get concurrency();
    private get operationsLockService();
    private get controller();
    private get registry();
    protected get metadata(): PipelineTemplateProps;
}

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 AwsS3BucketError extends Error {
    constructor(message: string);
}

type AwsBucketPaths$1 = {
    filesUpload: string;
};
type AwsBucketSettings = {
    awsAccessKeyId?: string;
    awsSecretAccessKey?: string;
    region?: string;
    defaultBucket: string;
    publicLinksExpirationMinutes: number;
    paths: AwsBucketPaths$1;
};

declare class AwsBucketModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AwsBucketSettings): DynamicModule;
    static initialize(input: AwsBucketSettings): void;
}

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>;
    fileExists(input: BucketFileExistsInput): Promise<boolean>;
    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
    fileUpload(input: BucketFileUploadInput): Promise<void>;
    fileDelete(input: BucketFileDeleteInput): Promise<void>;
    fileCopy(input: BucketFileCopyInput): Promise<void>;
    fileMove(input: BucketFileMoveInput): Promise<void>;
}

declare class InMemoryFileProvider implements IFileProvider {
    private readonly provider;
    constructor();
    getProviderId(): string;
    uploadFile(file: FileProviderUploadData): Promise<FileProviderReference>;
    deleteFile(reference: FileProviderReference): Promise<void>;
    downloadFile(reference: FileProviderReference): Promise<FileProviderDownloadData>;
    getFileProviderDownloadUrl(reference: FileProviderReference): Promise<FileProviderDownloadUrl>;
    get defaultBucket(): string;
}
declare class InMemoryBucketProvider implements IBucketProvider {
    private inMemoryStorage;
    private inMemoryFolders;
    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
    fileExists(input: BucketFileExistsInput): Promise<boolean>;
    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
    fileUpload(input: BucketFileUploadInput): Promise<void>;
    fileDelete(input: BucketFileDeleteInput): Promise<void>;
}

type DynamoItem = {
    [key: string]: AttributeValue;
};
type RawScanDynamoTableInput = {
    index?: string;
    pageSize: number;
    filter?: string;
    callback: (data: DynamoItem[]) => void;
};
type ScanDynamoTableInput<T> = {
    index?: string;
    pageSize: number;
    filter?: string;
    callback: (data: T[]) => void;
};
type ScanDynamoTableItemsInput = {
    index?: string;
    pageSize: number;
    filter?: string;
};
type SortDirection = "asc" | "desc";
type QueryDynamoTablePageInputBase = {
    index?: string;
    pageSize: number;
    cursor?: string;
    direction?: SortDirection;
    keyFilter?: string;
    dataFilter?: string;
};
type QueryDynamoTablePageInputRaw = QueryDynamoTablePageInputBase & {
    filterAttributes?: DynamoItem;
};
type QueryDynamoTablePageInput = QueryDynamoTablePageInputBase & {
    filterAttributes?: any;
};
type QueryDynamoTablePageRawResult = {
    items: DynamoItem[];
    cursor?: string;
};
type QueryDynamoTablePageResult<T> = {
    items: T[];
    cursor?: string;
};
type RawQueryDynamoTableInput = {
    index?: string;
    pageSize: number;
    keyFilter?: string;
    attributesFilter?: string;
    filterAttributes?: DynamoItem;
    callback: (data: DynamoItem[]) => void;
};
type QueryDynamoTableInput<T> = {
    index?: string;
    pageSize: number;
    keyFilter?: string;
    callback: (data: T[]) => void;
};
type QueryDynamoTableItemsInput = {
    index?: string;
    pageSize: number;
    keyFilter?: string;
    attributesFilter?: string;
    filterAttributes?: DynamoItem;
    direction?: SortDirection;
};

type DynamoDbPrimaryKey = {
    partitionKey: string;
    sortKey?: string;
};
type DynamoDbCollectionOptions = {
    tableName: string;
    primaryKey: DynamoDbPrimaryKey;
};
declare class DynamoDbCollection {
    private readonly settings;
    private client;
    constructor(settings: DynamoDbCollectionOptions);
    queryTableItems<T>(input: QueryDynamoTableItemsInput): Promise<T[]>;
    queryTable<T>(input: QueryDynamoTableInput<T>): Promise<void>;
    protected rawQueryTable(input: RawQueryDynamoTableInput): Promise<void>;
    queryTablePage<T>(input: QueryDynamoTablePageInput): Promise<QueryDynamoTablePageResult<T>>;
    protected queryTablePageRaw(input: QueryDynamoTablePageInputRaw): Promise<QueryDynamoTablePageRawResult>;
    scanTableItems<T>(input: ScanDynamoTableItemsInput): Promise<T[]>;
    scanTable<T>(input: ScanDynamoTableInput<T>): Promise<void>;
    protected rawScanTable(input: RawScanDynamoTableInput): Promise<void>;
    itemExists(key: DynamoItem): Promise<boolean>;
    getItem<T>(key: DynamoItem): Promise<T | undefined>;
    protected getItemRaw(key: DynamoItem): Promise<DynamoItem | undefined>;
    putItem<T>(item: T): Promise<void>;
    protected putItemRaw(item: DynamoItem): Promise<void>;
    deleteItem(key: DynamoItem): Promise<void>;
    private deserializeItem;
    private serializeItem;
    private serializeCursor;
    private deserializeCursor;
    private getClient;
}

type AwsDynamoDbSettings = {
    awsAccessKeyId?: string;
    awsSecretAccessKey?: string;
    region?: string;
};

declare class AwsDynamoDbModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AwsDynamoDbSettings): DynamicModule;
    static initialize(input: AwsDynamoDbSettings): void;
}

type AwsSesEmailTemplateData = {
    type: "html";
    subjectTemplate: string;
    bodyTemplate: string;
    from?: string;
    to?: string[];
    cc?: string[];
    bcc?: string[];
    replyTo?: string;
};

declare abstract class AwsSesEmailTemplate<TPayload, TAugmentedPayload = TPayload> implements IEmailTemplate<AwsSesEmailTemplateData, TPayload, TAugmentedPayload> {
    processPayload(payload: TPayload): Promise<TAugmentedPayload>;
    getTemplateData(payload: TAugmentedPayload): Promise<AwsSesEmailTemplateData>;
}

declare const WpAwsSesEmailTemplate: (templateId: string, templateData: 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[];
    sandboxMode?: boolean;
    sandboxAddresses?: string[];
};

declare class AwsEmailModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AwsSesSettings): DynamicModule;
    static initialize(input: AwsSesSettings): void;
}

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 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;
    sandboxMode?: boolean;
    forceDelivery?: boolean;
};

declare class SendgridEmailModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: SendgridSettings): DynamicModule;
    static initialize(input: SendgridSettings): void;
}

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>, options?: EmailSendOptions): Promise<void>;
    sendHtmlEmail<TPayload>(input: HtmlEmailInput<TPayload>): Promise<void>;
    getSentEmails(): SentEmail[];
}

type AwsBatchSettings = {
    awsAccessKeyId?: string;
    awsSecretAccessKey?: string;
    region?: string;
    defaultFargateBatchComputeEnvironment: string;
    defaultEc2BatchComputeEnvironment?: string;
    batchExecutionRole: string;
    batchResourcesPrefix: string;
};
declare const awsBatchSettings: AppInMemorySettings<AwsBatchSettings>;

declare class AwsJobsModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AwsBatchSettings): DynamicModule;
    static initialize(input: AwsBatchSettings): void;
}

declare class AwsS3MediaError extends Error {
    constructor(message: string);
}

type AwsBucketPaths = {
    filesUpload: string;
};
type AwsMediaSettings = {
    awsAccessKeyId?: string;
    awsSecretAccessKey?: string;
    region?: string;
    defaultBucket: string;
    paths: AwsBucketPaths;
};

declare class AwsS3MediaModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AwsMediaSettings): DynamicModule;
    static initialize(input: AwsMediaSettings): void;
}

declare class AwsS3MediaProvider implements IMediaProvider {
    private readonly client;
    constructor();
    getProviderId(): string;
    getFileName(input: MediaReference): string;
    mediaUpload(input: MediaUploadInput): Promise<MediaReference>;
    mediaDelete(input: MediaReference): Promise<void>;
    mediaDownload(input: MediaReference): Promise<Buffer>;
    private buildUploadPath;
}

declare class SanityMediaError extends Error {
    constructor(message: string);
}

type SanityMediaSettings = {
    projectId: string;
    dataset: string;
    token: string;
    apiVersion: string;
};

declare class SanityMediaModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: SanityMediaSettings): DynamicModule;
    static initialize(input: SanityMediaSettings): void;
}

declare class SanityMediaProvider implements IMediaProvider {
    private readonly client;
    constructor();
    getProviderId(): string;
    getFileName(input: MediaReference): string;
    mediaUpload(input: MediaUploadInput): Promise<MediaReference>;
    mediaDelete(input: MediaReference): Promise<void>;
    mediaDownload(input: MediaReference): Promise<Buffer>;
}

declare class InMemoryMediaProvider implements IMediaProvider {
    private readonly provider;
    mediaUpload(input: MediaUploadInput): Promise<MediaReference>;
    mediaDelete(input: MediaReference): Promise<void>;
    mediaDownload(input: MediaReference): Promise<Buffer>;
    getFileName(input: MediaReference): string;
    getProviderId(): string;
}

type AwsSecretsSettings = {
    awsAccessKeyId?: string;
    awsSecretAccessKey?: string;
    region?: string;
    secretsRootPath: string;
};

declare class AwsSecretsModule {
    /**
     * @deprecated use initialize instead
     */
    static forRoot(input: AwsSecretsSettings): DynamicModule;
    static initialize(input: AwsSecretsSettings): void;
}

declare class AwsSecretsProvider implements ISecretsProvider {
    private readonly client;
    private readonly logger;
    constructor();
    getSecretValue<TValue>(pageName: string, key: string): Promise<TValue | undefined>;
    getSecrets(pageName: string): Promise<AppSecret<any>[]>;
    setSecret<TValue>(pageName: string, secret: AppSecretInput<TValue>): Promise<void>;
    defineSecret(pageName: string, definition: AppSecretDefinition): Promise<void>;
    pageEnsure(pageName: string, metadata: AppSecretsPageMetadata): Promise<void>;
    pageExists(pageName: string): Promise<boolean>;
    pageInitialize(pageName: string, metadata: AppSecretsPageMetadata): Promise<void>;
    private saveSecretsPage;
    private getSecretsPage;
    private buildPagePath;
}

declare class NestEventEmitter implements IEventEmitter {
    private eventEmitter;
    constructor(eventEmitter: EventEmitter2);
    emit(event: string, ...args: any[]): Promise<void>;
}

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 registerMediaProviders;
    private registerMediaReferenceRepositoryProviders;
    private registerMediaFolderRepositoryProviders;
    private registerGlobalAuthenticationMiddlewares;
    private registerSecretsProviders;
    private registerBucketProviders;
    private registerCacheInstances;
    private registerFilesReferenceRepositoryProviders;
    private registerEventTrackingProviders;
    private registerEmailLogger;
    private registerEmailTemplateMiddleware;
    private registerVersioningProviders;
    private registerEmailProviders;
    private registerEmailTemplates;
    private registerOperationLockService;
    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 discoverEntityConnectors;
    private discoverEntityConnectorMappers;
    private discoverAppInitializers;
    private discoverEntitySeeders;
    private discoverEmailTemplates;
    private discoverEmailProviders;
    private discoverEventTrackingProviders;
    private discoverEmailLogger;
    private discoverEmailTemplateMiddleware;
    private discoverOperationLockService;
    private discoverBucketProviders;
    private discoverSecretsProviders;
    private discoverCacheInstances;
    private discoverFileProviders;
    private discoverFilesReferenceRepositoryProviders;
    private discoverMediaProviders;
    private discoverMediaReferenceRepositories;
    private discoverMediaFolderRepositories;
}

declare class AppSessionMiddleware implements NestMiddleware {
    use(req: Request, res: Response, next: NextFunction): void;
}

declare class AppSession<TRequest, TResponse> {
    private readonly _request;
    private readonly _response;
    private readonly _map;
    constructor(request: TRequest, response: TResponse);
    get<T>(key: string): T;
    set<T>(key: string, value: T): void;
    delete(key: string): void;
    clear(): void;
    get request(): TRequest;
    get response(): TResponse;
}

declare const sessionStorage: AsyncLocalStorage<AppSession<Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, Response<any, Record<string, any>>>>;

declare class EntityManagerModule implements OnModuleInit {
    private readonly registry;
    constructor(registry: EntityManagerRegistry);
    onModuleInit(): void;
}

interface IAuthenticationUserRole {
    uid: string;
}
interface IAuthenticationUserPermission {
    uid: string;
}
interface IAuthenticationOrganizationalUnit {
    id: string;
    uid: string;
}
interface IAuthenticationContext<TUserContextData> {
    isAuthenticated: boolean;
    isAnonymous: boolean;
    apiKeyId?: string;
    userId?: string;
    userContext?: TUserContextData;
    userRoles?: IAuthenticationUserRole[];
    userPermissions?: IAuthenticationUserPermission[];
    userOrganizationalUnits?: IAuthenticationOrganizationalUnit[];
}
interface IAuthenticationContextProvider<TUserContext> {
    getContext(): Promise<IAuthenticationContext<TUserContext>>;
}
interface IAuthenticationData {
    user: IAuthUser;
    roles: IAuthenticationUserRole[];
    permissions: IAuthenticationUserPermission[];
    organizationalUnits: IAuthenticationOrganizationalUnit[];
}
interface IAuthenticationMiddleware<TAuthenticationData extends IAuthenticationData, TOutput> {
    processContext(data: TAuthenticationData): Promise<TOutput>;
    getPriority(): number;
}

interface IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
    relations?: TEntitySearchParameters["relations"];
}
interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
    execute(request: TEntitySearchParameters, options?: IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
}
interface IEntityGetQueryOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
    relations?: TEntitySearchParameters["relations"];
}
interface IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
    execute(id: TEntityId, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): Promise<TEntity | undefined>;
}
interface IEntitiesFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor> {
    execute(request: {
        filters?: TEntitySearchParameters["filters"];
        sorting?: TEntitySearchParameters["sorting"];
        relations?: TEntitySearchParameters["relations"];
    }): Promise<TEntity>;
}
interface IEntityExistsQuery<TEntity, TEntityFilters extends ISearchFilters> {
    execute(filters: TEntityFilters): Promise<boolean>;
}
interface IEntitiesCountQuery<TEntity, TEntityFilters extends ISearchFilters> {
    execute(filters: TEntityFilters): Promise<number>;
}
interface IEntityVersionsSearchQuery<TEntity, TCursor> {
    execute(params: IEntityVersionsSearchParameters<TCursor>): Promise<IEntityVersionsSearchResults<TEntity, TCursor>>;
}
interface IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): Promise<TEntity | undefined>;
    find(request?: {
        filters?: TEntitySearchParameters["filters"];
        sorting?: TEntitySearchParameters["sorting"];
        relations?: TEntitySearchParameters["relations"];
    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
    search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
    exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<boolean>;
    count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<number>;
    delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesDeleteResult>;
}

interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
    execute(input: TEntityCreateDto): Promise<TEntityDto>;
}
interface IEntityDeleteAction<TEntity, TEntityId> {
    execute(id: TEntityId): Promise<void>;
}
interface IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> {
    execute(params: TEntitiesDeleteParameters): Promise<void>;
}
interface IEntityGetActionOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> extends IEntityGetQueryOptions<TEntity, TEntitySearchParameters> {
}
interface IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
    execute(id: TEntityId, options?: IEntityGetActionOptions<TEntity, TEntitySearchParameters>): Promise<TEntityDto | undefined>;
}
interface IEntityExistsAction<TEntity, TEntityFilters extends ISearchFilters> {
    execute(filters: TEntityFilters): Promise<boolean>;
}
interface IEntitiesCountAction<TEntity, TEntityFilters extends ISearchFilters> {
    execute(filters: TEntityFilters): Promise<number>;
}
interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
    execute(id: TEntityId, data: TEntityUpdateDto): Promise<TEntityDto>;
}
interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
    execute(id: TEntityId, input: TEntityUpdateDto): Promise<TEntityDto>;
}
interface IEntitiesSearchActionOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>, TListItemDto> extends IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters> {
    converter?: (item: TEntity) => TListItemDto;
}
interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
    execute(request: TEntitySearchParameters, options?: IEntitiesSearchActionOptions<TEntity, TEntitySearchParameters, TEntityListItemDto>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
}
interface IEntitiesExportAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor> {
    execute<TPayload = unknown>(input: EntitiesExportInput<TEntity, TEntitySearchParameters, TSorting, TCursor, TPayload>): Promise<EntitiesExportResult>;
}
interface IEntitiesImportAction<TEntity> {
    execute<TPayload = unknown>(input: EntitiesImportInput<TPayload>): Promise<EntitiesImportResult>;
}
interface IEntitiesParseAction<TEntity> {
    execute<TPayload = unknown>(input: EntitiesParseInput<TPayload>): Promise<EntitiesParseResult<unknown>>;
}
interface IEntitiesSampleDownloadAction<TEntity> {
    execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;
}
interface IEntityVersionsSearchAction<TEntity, TEntityVersionDto, TCursor> {
    execute(request: IEntityVersionsSearchRequest<TCursor>): Promise<IEntityVersionsSearchResponse<TEntityVersionDto, TCursor>>;
}
interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
    get search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
    get exists(): IEntityExistsAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
    get count(): IEntitiesCountAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
    get create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
    get update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
    get upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
    get delete(): IEntityDeleteAction<TEntity, TEntityId>;
    get deleteItems(): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
    get export(): IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor>;
    get import(): IEntitiesImportAction<TEntity>;
    get parse(): IEntitiesParseAction<TEntity>;
    get sampleDownload(): IEntitiesSampleDownloadAction<TEntity>;
    get versions(): IEntityVersionsSearchAction<TEntity, TEntityListItemDto, TCursor>;
}

interface IAppInitializer {
    initialize(app: INestApplicationContext): Promise<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 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, TEntityId, TMappedType>>({ name, options, connector, mapper, }: {
        name: string;
        options: ConnectorOptions;
        connector: TEntityConnector;
        mapper: TMapper;
    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
}

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;
    private readonly entityType;
    constructor(entityData: {
        id: TEntityId;
        type: string;
    });
    getEntityId(): TEntityId | undefined;
    getEntityType(): string | undefined;
}
declare class MultipleEntitiesFoundException extends EntityManagerException {
    constructor(params: object, items: any[]);
}
declare class EntityManagerConfigurationError extends EntityManagerException {
    constructor(message: string);
}
declare class MissingEntityIdError extends EntityManagerException {
    constructor();
}

type FilterExpression<TEntity> = (entity: TEntity) => boolean;

type LocalizedMap<T> = {
    [key: string]: T;
};
type LocalizedTexts = LocalizedMap<string>;

declare const createContainer: () => IEntityManagerServiceRoot;

type toEntitiesImportInputOptions<TPayload> = Omit<EntitiesImportInput<TPayload>, "file"> & {
    file: Express.Multer.File;
};
declare const toEntitiesImportInput: <TPayload>(request: toEntitiesImportInputOptions<TPayload>) => EntitiesImportInput<TPayload>;

declare const PLATFORM_EVENT_NAMESPACE = "platform";
declare const PlatformEvents: {
    Messaging: {
        EmailSent: string;
    };
};

interface MessagingEmailSentPayload {
    from?: string;
    to?: string[];
    cc?: string[];
    bcc?: string[];
    subject?: string;
    body?: string;
    payload?: any;
    request?: any;
}

declare class InMemorySecretsProvider implements ISecretsProvider {
    private readonly secrets;
    getSecrets(pageName: string): Promise<AppSecret<any>[]>;
    setSecret<TValue>(pageName: string, secret: AppSecret<TValue>): Promise<void>;
    defineSecret(pageName: string, definition: AppSecretDefinition): Promise<void>;
    pageInitialize(pageName: string, metadata: AppSecretsPageMetadata): Promise<void>;
    pageEnsure(pageName: string, metadata: AppSecretsPageMetadata): Promise<void>;
    pageExists(pageName: string): Promise<boolean>;
}

declare class TestingAppSessionService implements IAppSessionService<unknown> {
    private readonly values;
    getValue<T>(key: string): T;
    setValue<T>(key: string, value: T): void;
    clearValue(key: string): void;
    getRequest(): any;
    mockRequest(request: any): void;
    retrieveRequest(): any;
}

declare const getLocalizedText: (item: string | LocalizedTexts, languageId: string, defaultLanguageId?: string) => string;

declare const renderHandlebarsTemplate: <TContext extends object>(input: {
    template: string;
    context: TContext;
}) => string;

declare const newUuid: () => string;

declare const fieldRequiredValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => any) => EntryValidationResult;
declare const fieldNumericValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => number, params?: {
    min?: number;
    max?: number;
}) => EntryValidationResult;
declare const fieldTextValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => string | string[], params: {
    required?: boolean;
    minLength?: number;
    maxLength?: number;
    regex?: RegExp;
    regexErrorCode?: string;
}) => EntryValidationResult;
declare const fieldEmailValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => any, params: {
    required?: boolean;
}) => EntryValidationResult;
declare const fieldOptionValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => string, { availableOptions, required, }: {
    availableOptions: string[];
    required?: boolean | undefined;
}) => EntryValidationResult;
declare const fieldOptionsValidator: <TSheetItem>(item: TSheetItem, selector: (item: TSheetItem) => string[], { availableOptions, minSelected, maxSelected, }: {
    availableOptions: string[];
    minSelected?: number | undefined;
    maxSelected?: number | undefined;
}) => EntryValidationResult;

export { AUTHENTICATION_EVENTS_NAMESPACE, ApiKeyAccess, ApiKeyRouteOptions, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppPermission, AppRole, AppSecret, AppSecretDefinition, AppSecretInput, AppSecretType, AppSecretsPageMetadata, AppSession, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationModuleSettings, AuthenticationService, AwsBatchInfrastructureParams, AwsBatchInvocationParams, AwsBatchSettings, AwsBucketModule, AwsBucketSettings, AwsDynamoDbModule, AwsDynamoDbSettings, AwsEmailModule, AwsJobComputePlatformType, AwsJobDefinition, AwsJobEnvironmentVariable, AwsJobsModule, AwsMediaSettings, AwsS3BucketError, AwsS3BucketProvider, AwsS3MediaError, AwsS3MediaModule, AwsS3MediaProvider, AwsSecretsModule, AwsSecretsProvider, AwsSecretsSettings, AwsSesEmailTemplate, AwsSesEmailTemplateData, AwsSesSettings, BooleanFacetsType, BucketContentItem, BucketFileCopyInput, BucketFileDeleteInput, BucketFileDownloadInput, BucketFileExistsInput, BucketFileMoveInput, BucketFilePublicUrlCreateInput, BucketFileUploadInput, BucketFolderContentResult, BucketFolderCreateInput, BucketFolderEnsureInput, BucketFolderExistsInput, BucketFolderListInput, BucketFolderListResult, BucketItemType, BucketProviderProps, CacheEntryDetail, CacheEntryInfo, CacheInstanceProps, CacheService, CacheTtl, ClassType, ConnectorMode, ConnectorOptions, CurrentUser, CurrentUserData, CustomDiscoveryModule, CustomDiscoveryService, DataExportFile, DataExportInput, DataExportService, DataSerializationFormat, DataSerializerColumnDefinition, DataSheet, DataSheetsBuilder, DataSheetsExporterService, DateFacetsType, DeepPartial, DynamoDbCacheInstance, DynamoDbCacheItem, DynamoDbCollection, EmailAttachmentData, EmailLoggerProps, EmailProviderProps, EmailSendOptions, EmailService, EmailTemplateMiddlewareProps, EmailTemplateProps, EmailVerifyEmailPayload, EmailVerifyTokenPayload, EntitiesExportFile, EntitiesExportInput, EntitiesExportOptions, EntitiesExportResult, EntitiesImportExportSettings, EntitiesImportInput, EntitiesImportResult, EntitiesImportStatistics, EntitiesParseError, EntitiesParseInput, EntitiesParseInputFile, EntitiesParseResult, EntitiesParseResultItem, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult, EntityActionsProps, EntityAdapterProps, EntityAuthMiddlewareProps, EntityConnectorMapperProps, EntityConnectorProps, EntityConverterProps, EntityExportBucketSettings, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerProps, EntityManagerRegistry, EntityManagerService, EntityManagerSettings, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityParseResult, EntityParseValidationError, EntityProps, EntityQueryBuilderProps, EntityReference, EntityRepositoryProps, EntitySeeder, EntitySeederProps, EntitySerializationFormat, EntitySerializer, EntitySerializerColumnDefinition, EntitySerializerProps, EntitySerializerSheetDefinition, EntitySnapshotService, EntitySnapshotServiceProps, EntityVersionInput, EntityVersionOperation, EntityVersioningProviderProps, EntryValidationError, EntryValidationResult, EnumType, EventsService, EventsTrackerProps, ExclusiveOperationResult, ExecuteExclusiveInput, ExecuteSequentialInput, FacetBuilderInput, FacetRelations, FacetType, FacetValueType, FileData, FileDownloadUrl, FileProviderDownloadData, FileProviderDownloadUrl, FileProviderProps, FileProviderReference, FileProviderUploadData, FileReference, FileReferenceRecord, FileReferenceRepositoryProps, FilesManager, FilesReferenceData, FilterExpression, GlobalAuthenticationMiddlewareProps, HtmlEmailInput, IAppCompany, IAppDirectory, IAppDivision, IAppInitializer, IAppOrganization, IAppRole, IAppSessionService, IAppTenant, IAppUser, IAppUserGroup, IAppUserProfile, IAuthApiKey, IAuthApiKeysService, IAuthDirectory, IAuthOrganization, IAuthOrganizationalUnit, IAuthPermission, IAuthPermissionService, IAuthRole, IAuthRoleService, IAuthService, IAuthTenant, IAuthUser, IAuthUserContext, IAuthUserProfile, IAuthUserRolesService, IAuthUserService, IAuthUserTokenData, IAuthenticationContext, IAuthenticationContextProvider, IAuthenticationData, IAuthenticationMiddleware, IAuthenticationOrganizationalUnit, IAuthenticationUserPermission, IAuthenticationUserRole, IAuthorizationResult, IBucketProvider, ICache, ICacheDatabaseItem, ICacheInstance, IEmailLogger, IEmailProvider, IEmailTemplate, IEmailTemplateMiddleware, IEmailTemplatesCollection, IEntitiesCountAction, IEntitiesCountQuery, IEntitiesDeleteAction, IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesDeleteResult$1 as IEntitiesDeleteResult, IEntitiesExportAction, IEntitiesExportCommand, IEntitiesImportAction, IEntitiesImportCommand, IEntitiesParseAction, IEntitiesParseCommand, IEntitiesQueryBuilder, IEntitiesSampleDownloadAction, IEntitiesSampleDownloadCommand, IEntitiesSearchAction, IEntitiesSearchQuery, IEntitiesSearchResults, IEntitiesSearchResultsPaging, IEntityActions, IEntityAdapter, IEntityAuthorizationMiddleware, IEntityConnector, 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, IEntityUpsertByCommand, IEntityUpsertByParameters, IEntityUpsertByResult, IEntityUpsertCommand, IEntityVersionCommand, IEntityVersioningProvider, IEntityVersioningResults, IEntityVersionsCursor, IEntityVersionsFilters, IEntityVersionsReference, IEntityVersionsResultsPaging, IEntityVersionsSearchAction, IEntityVersionsSearchInput, IEntityVersionsSearchParameters, IEntityVersionsSearchQuery, IEntityVersionsSearchResults, IEntityVersionsSorting, IEventLog, IEventsTracker, IFileManager, IFileProvider, IFilesReferenceRepository, IFullTextQuery, IJobDefinitionsRepository, IJobInstancesRepository, ILockRepository, IMediaFolderRepository, IMediaLibraryManager, IMediaProvider, IMediaReferenceRepository, IMultiCompanyEntity, IMultiOrganizationEntity, IMultiTenantEntity, IOperationLockService, IPipelineStepBuilder, IPipelineStepOperationBuilder, IPipelineStepOperationOptionsBuilder, IPipelineTemplateBuilder, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchQueryRelations, ISearchQueryRelationsProperty, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, ISecretsProvider, ITask, ITraverseFilters, InMemoryBucketProvider, InMemoryCacheEntry, InMemoryCacheInstance, InMemoryEmailProvider, InMemoryFileProvider, InMemoryMediaProvider, InMemorySecretsProvider, InvalidCredentialsError, InvalidEntityHandling, JobConcurrency, JobDefinition, JobInstance, JobProviderState$1 as JobProviderState, JobRunType, JobSchedule, JobStatus, JobTriggerInput, JobsModule, JobsService, JobsSettings, LocalizedMap, LocalizedTexts, LockAcquireInput, LockAcquireResult, LockItem, LockNotFoundError, LockReleaseInput, MediaFolderCreateInput, MediaFolderEnsureInput, MediaFolderMoveInput, MediaFolderRecord, MediaFolderReference, MediaFolderRenameInput, MediaFolderRepositoryProps, MediaInfo, MediaItemReference, MediaLibraryService, MediaProviderProps, MediaReference, MediaReferenceCreateInput, MediaReferenceRecord, MediaReferenceRepositoryProps, MediaUploadInput, MemberOf, MessagingEmailSentPayload, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestEntitySerializer, NestEntitySnapshotService, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NonNullable$1 as NonNullable, NumberFacetsType, OperationDefinition, OperationLockService, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PasswordResetEmailPayload, Permissions, PipelineCompletedStepState, PipelineController, PipelineCurrentStepState, PipelineDefinition, PipelineErrorType, PipelineInvocationError, PipelineOperationError, PipelineOperationResult, PipelineOperationResultType, PipelineOperationRollbackResult, PipelineOperationRollbackResultType, PipelineResult, PipelineResultType, PipelineStatus, PipelineStep, PipelineStepErrorType, PipelineStepOperation, PipelineStepReference, PipelineStepResult, PipelineStepResultType, PipelineStepRollbackResult, PipelineStepRollbackResultType, PipelineStepState, PipelineTemplateProps, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, QueryBuilderOperation, RegistrationEmailPayload, ReplicaConfiguration, ReplicaOptions, ReplicationMode, Roles, RolesGuardOptions, RollbackOperationDefinition, RuntimeErrorInformation, SanityMediaError, SanityMediaModule, SanityMediaProvider, SanityMediaSettings, SecretsService, SendgridEmailModule, SendgridEmailTemplate, SendgridEmailTemplateData, SendgridSettings, SendgridTemplateBaseData, SendgridTemplateType, SortDirection$1 as SortDirection, SortingType, StringFacetsType, TaskConcurrency, TaskContext, TaskRunType, TaskSettings, TasksModule, TasksModuleSettings, TasksService, TemplatedEmailInput, TestingAppSessionService, TrackingService, TypeOrmQueryBuilder, TypeOrmRepository, TypeormCacheInstance, TypeormOperationLockRepository, 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, WpApiKeysService, WpAppInitializer, WpAwsSesEmailTemplate, WpBucketProvider, WpCacheInstance, WpEmailLogger, WpEmailProvider, WpEmailTemplate, WpEmailTemplateMiddleware, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConnectorMapper, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEntitySerializer, WpEntitySnapshotService, WpEntityVersioningProvider, WpEventsTracker, WpFileProvider, WpFileReferenceRepository, WpGlobalAuthenticationMiddleware, WpMediaFolderRepository, WpMediaProvider, WpMediaReferenceRepository, WpPermissionsService, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpTask, WpUserRolesService, WpUserService, awsBatchSettings, buildPermissionsGuard, buildProviderToken, buildRolesGuard, createContainer, createExpressFileResponse, fieldEmailValidator, fieldNumericValidator, fieldOptionValidator, fieldOptionsValidator, fieldRequiredValidator, fieldTextValidator, getEntityManagerProviderToken, getLocalizedText, newUuid, renderHandlebarsTemplate, sessionStorage, toEntitiesImportInput };