@punks/backend-entity-manager 0.0.1

package/dist/esm/types/concrete/index.d.ts

@@ -0,0 +1,27 @@
+import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
+import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
+import { SortingType } from "../abstractions/common";
+import { IEntityManager } from "../abstractions/manager";
+import { IEntitiesSearchQuery, IEntityGetQuery } from "../abstractions/queries";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityManager<TEntity, TEntityId> implements IEntityManager<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    get<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
+    search<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    create<TEntityCreateInput>(): IEntityCreateCommand<TEntity, TEntityCreateInput>;
+    update<TEntityUpdateInput>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateInput>;
+    upsert<TEntityUpdateInput>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateInput>;
+    delete<TEntityId>(): IEntityDeleteCommand<TEntity, TEntityId>;
+}
+export declare class EntityActions<TEntity, TEntityId> implements IEntityActions<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    get<TEntityId, TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    search<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    create<TEntityCreateInput, TEntityDto>(): IEntityCreateAction<TEntity, TEntityCreateInput, TEntityDto>;
+    update<TEntityUpdateInput, TEntityDto>(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateInput, TEntityDto>;
+    upsert<TEntityUpdateInput, TEntityDto>(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateInput, TEntityDto>;
+    delete(): IEntityDeleteAction<TEntity, TEntityId>;
+}

package/dist/esm/types/configuration/connectors.d.ts

@@ -0,0 +1,8 @@
+import { ConnectorConfiguration, ConnectorOptions, IConnectorsConfiguration, IEntityConnector } from "../abstractions/connectors";
+import { IEntityMapper } from "../abstractions/mappers";
+export declare class ConnectorsConfiguration<TEntity> implements IConnectorsConfiguration<TEntity> {
+    private readonly connectors;
+    configureConnector<TEntityConnector extends IEntityConnector<TEntity, TMappedType>, TMappedType, TMapper extends IEntityMapper<TEntity, TMappedType>>(name: string, options: ConnectorOptions, connector: TEntityConnector, mapper: TMapper): void;
+    getConnector(name: string): ConnectorConfiguration<TEntity>;
+    getConnectors(): ConnectorConfiguration<TEntity>[];
+}

package/dist/esm/types/configuration/index.d.ts

@@ -0,0 +1 @@
+export { createContainer } from "./root";

package/dist/esm/types/configuration/replicas.d.ts

@@ -0,0 +1,8 @@
+import { IReplicasConfiguration, ReplicaConfiguration, ReplicaOptions } from "../abstractions/replication";
+import { IEntityRepository } from "../abstractions/repository";
+export declare class ReplicasConfiguration<TEntity, TEntityId> implements IReplicasConfiguration<TEntity, TEntityId> {
+    private readonly replicas;
+    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>[];
+}

package/dist/esm/types/configuration/root.d.ts

@@ -0,0 +1,2 @@
+import { IEntityManagerServiceRoot } from "../abstractions/configuration";
+export declare const createContainer: () => IEntityManagerServiceRoot;

package/dist/esm/types/decorators/decorators.test.d.ts

@@ -0,0 +1,2 @@
+export declare class TestClass {
+}

package/dist/esm/types/decorators/index.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export declare function Entity(metadata: string): (target: any) => void;
+export declare const getEntityName: (target: Object) => any;

package/dist/esm/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./abstractions";
+export * from "./platforms";

package/dist/esm/types/integrations/repository/typeorm/index.d.ts

@@ -0,0 +1 @@
+export * from "./repository";

package/dist/esm/types/integrations/repository/typeorm/repository.d.ts

@@ -0,0 +1,22 @@
+import { FindManyOptions, FindOneOptions, FindOptionsWhere, ObjectId, ObjectLiteral, Repository } from "typeorm";
+import { IEntityRepository } from "../../../abstractions";
+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>;
+export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
+    private readonly innerRepository;
+    constructor(innerRepository: Repository<TEntity>);
+    exists(id: TEntityId): Promise<boolean>;
+    existsBy(condition: FindOneOptions<TEntity>): Promise<boolean>;
+    get(id: TEntityId): Promise<TEntity | undefined>;
+    getBy(condition: FindOneOptions<TEntity>): Promise<TEntity | undefined>;
+    all(): Promise<TEntity[]>;
+    find(condition: FindManyOptions<TEntity>): Promise<TEntity[]>;
+    findById(id: TEntityId[]): Promise<TEntity[]>;
+    delete(id: TEntityId): Promise<void>;
+    deleteBy(condition: DeleteCriteria<TEntity>): Promise<void>;
+    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>;
+}
+export {};

package/dist/esm/types/ioc/index.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "../abstractions/common";
+import { IResolveServiceOptions, IServiceLocator } from "../abstractions/ioc";
+export declare class ServiceLocator implements IServiceLocator {
+    private services;
+    register<T>(name: 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;
+    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
+    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
+    private buildServiceTypeName;
+    private buildServiceName;
+}

package/dist/esm/types/models/index.d.ts

@@ -0,0 +1 @@
+export { EntitiesSearchResultsPaging, EntitiesSearchResults } from "./search";

package/dist/esm/types/models/search.d.ts

@@ -0,0 +1,17 @@
+import { SortingType } from "../abstractions/common";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+export type EntitiesSearchResultsPaging<TCursor> = {
+    pageIndex: number;
+    pageSize: number;
+    totPages: number;
+    totItems: number;
+    nextPageCursor?: TCursor;
+    currentPageCursor?: TCursor;
+    prevPageCursor?: TCursor;
+};
+export type EntitiesSearchResults<TSearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> = {
+    request: TSearchParameters;
+    items: TResult[];
+    facets?: TFacets;
+    paging?: EntitiesSearchResultsPaging<TCursor>;
+};

package/dist/esm/types/platforms/index.d.ts

@@ -0,0 +1 @@
+export * from "./nest";

package/dist/esm/types/platforms/nest/index.d.ts

@@ -0,0 +1 @@
+export { EntityManagerModule } from "./module";

package/dist/esm/types/platforms/nest/ioc/container/index.d.ts

@@ -0,0 +1,3 @@
+export declare class EntityManagerContainerProvider {
+    private readonly container;
+}

package/dist/esm/types/platforms/nest/module.d.ts

@@ -0,0 +1,5 @@
+import { OnModuleInit } from "@nestjs/common";
+export declare class EntityManagerModule implements OnModuleInit {
+    private readonly logger;
+    onModuleInit(): void;
+}

package/dist/esm/types/platforms/nest/services/manager/index.d.ts

@@ -0,0 +1,2 @@
+export declare class EntityManagerService {
+}

package/dist/esm/types/providers/services.d.ts

@@ -0,0 +1,114 @@
+import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
+import { IEntityAuthorizationMiddleware } from "../abstractions/authorization";
+import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
+import { SortingType } from "../abstractions/common";
+import { IConnectorsConfiguration, IEntityConnectorDeleteManager, IEntityConnectorSyncManager } from "../abstractions/connectors";
+import { IEntitiesSearchConverter, IEntityCreateCommandConverter, IEntityCreateConverter, IEntityGetConverter, IEntityUpdateActionConverter, IEntityUpdateCommandConverter } from "../abstractions/converters";
+import { IEntityEventsManager } from "../abstractions/events";
+import { IEntityManager } from "../abstractions/manager";
+import { IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityGetQuery } from "../abstractions/queries";
+import { IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IReplicasConfiguration } from "../abstractions/replication";
+import { IEntityRepository } from "../abstractions/repository";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { ServiceLocator } from "../ioc";
+export declare class EntityServiceLocator<TEntity, TEntityId> {
+    private readonly services;
+    private readonly entityName;
+    constructor(services: EntitiesServiceLocator, entityName: string);
+    resolveEntityManager(): IEntityManager<TEntity, TEntityId>;
+    resolveEntityActions(): IEntityActions<TEntity, TEntityId>;
+    resolveRepository<TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
+    resolveEventsManager(): IEntityEventsManager<TEntity, TEntityId>;
+    resolveReplicaSyncManager<TEntity>(): IEntityReplicaSyncManager<TEntity>;
+    resolveReplicaConfiguration<TEntity>(): IReplicasConfiguration<TEntity, TEntityId>;
+    resolveReplicaDeleteManager<TEntity, TEntityId>(): IEntityReplicaDeleteManager<TEntity, TEntityId>;
+    resolveConnectorSyncManager<TEntity>(): IEntityConnectorSyncManager<TEntity>;
+    resolveConnectorDeleteManager<TEntity, TEntityId>(): IEntityConnectorDeleteManager<TEntity, TEntityId>;
+    resolveConnectorsConfiguration<TEntity>(): IConnectorsConfiguration<TEntity>;
+    resolveCreateCommandConverter<TEntityCreateData>(): IEntityCreateCommandConverter<TEntity, TEntityCreateData> | undefined;
+    resolveUpdateCommandConverter<TEntityUpdateData>(): IEntityUpdateCommandConverter<TEntity, TEntityUpdateData>;
+    resolveSearchConverter<TListItemDto>(): IEntitiesSearchConverter<TEntity, TListItemDto> | undefined;
+    resolveGetConverter<TEntityDto>(): IEntityGetConverter<TEntity, TEntityDto> | undefined;
+    resolveCreateConverter<TEntityCreateData, TEntityDto>(): IEntityCreateConverter<TEntity, TEntityCreateData, TEntityDto> | undefined;
+    resolveUpdateActionConverter<TEntityDto>(): IEntityUpdateActionConverter<TEntity, TEntityDto> | undefined;
+    resolveAuthorizationMiddleware(): IEntityAuthorizationMiddleware<TEntity> | undefined;
+    resolveGetQuery<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
+    resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    resolveCreateCommand<TEntityCreateData>(): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    resolveUpdateCommand<TEntityUpdateData>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    resolveUpsertCommand<TEntityUpdateData>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    resolveDeleteCommand<TEntityId>(): IEntityDeleteCommand<TEntity, TEntityId>;
+    resolveGetAction<TEntityId, TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    resolveSearchAction<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    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>;
+    resolveQueryBuilder<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    getEntityName(): string;
+}
+export declare class EntitiesServiceLocator {
+    private readonly provider;
+    constructor(provider: ServiceLocator);
+    getProvider(): ServiceLocator;
+    resolveEntityManager<TEntity, TEntityId>(entityName: string): IEntityManager<TEntity, TEntityId>;
+    registerEntityManager<TEntity, TEntityId>(entityName: string, instance: IEntityManager<TEntity, TEntityId>): void;
+    resolveEntityActions<TEntity, TEntityId>(entityName: string): IEntityActions<TEntity, TEntityId>;
+    registerEntityActions<TEntity, TEntityId>(entityName: string, instance: IEntityActions<TEntity, TEntityId>): 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;
+    resolveCreateCommandConverter<TEntity, TEntityCreateData>(entityName: string): IEntityCreateCommandConverter<TEntity, TEntityCreateData> | undefined;
+    registerCreateCommandConverter<TEntity, TEntityCreateData>(entityName: string, instance: IEntityCreateCommandConverter<TEntity, TEntityCreateData>): void;
+    resolveUpdateCommandConverter<TEntity, TEntityUpdateData>(entityName: string): IEntityUpdateCommandConverter<TEntity, TEntityUpdateData>;
+    registerUpdateCommandConverter<TEntity, TEntityUpdateData>(entityName: string, instance: IEntityUpdateCommandConverter<TEntity, TEntityUpdateData>): void;
+    resolveSearchConverter<TEntity, TListItemDto>(entityName: string): IEntitiesSearchConverter<TEntity, TListItemDto> | undefined;
+    registerSearchConverter<TEntity, TListItemDto>(entityName: string, instance: IEntitiesSearchConverter<TEntity, TListItemDto>): void;
+    resolveGetConverter<TEntity, TEntityDto>(entityName: string): IEntityGetConverter<TEntity, TEntityDto> | undefined;
+    registerGetConverter<TEntity, TEntityDto>(entityName: string, instance: IEntityGetConverter<TEntity, TEntityDto>): void;
+    resolveCreateConverter<TEntity, TEntityCreateData, TEntityDto>(entityName: string): IEntityCreateConverter<TEntity, TEntityCreateData, TEntityDto> | undefined;
+    registerCreateActionConverter<TEntity, TEntityCreateData, TEntityDto>(entityName: string, instance: IEntityCreateConverter<TEntity, TEntityCreateData, TEntityDto>): void;
+    resolveUpdateActionConverter<TEntity, TEntityDto>(entityName: string): IEntityUpdateActionConverter<TEntity, TEntityDto> | undefined;
+    registerUpdateActionConverter<TEntity, TEntityDto>(entityName: string, instance: IEntityUpdateActionConverter<TEntity, TEntityDto>): void;
+    resolveAuthorizationMiddleware<TEntity>(entityName: string): IEntityAuthorizationMiddleware<TEntity> | undefined;
+    registerAuthorizationMiddleware<TEntity>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity>): void;
+    resolveGetQuery<TEntity, TEntityId>(entityName: string): IEntityGetQuery<TEntity, TEntityId>;
+    registerGetQuery<TEntity, TEntityId>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId>): void;
+    resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string, instance: IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
+    resolveCreateCommand<TEntity, TEntityCreateData>(entityName: string): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    registerCreateCommand<TEntity, TEntityCreateData>(entityName: string, instance: IEntityCreateCommand<TEntity, 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;
+    resolveDeleteCommand<TEntity, TEntityId>(entityName: string): IEntityDeleteCommand<TEntity, TEntityId>;
+    registerDeleteCommand<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteCommand<TEntity, TEntityId>): void;
+    resolveGetAction<TEntity, TEntityId, TEntityDto>(entityName: string): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    registerGetAction<TEntity, TEntityId, TEntityDto>(entityName: string, instance: IEntityGetAction<TEntity, TEntityId, TEntityDto>): void;
+    resolveSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(entityName: string): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    registerSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(entityName: string, instance: IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>): 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;
+    resolveQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    registerQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
+}

package/dist/esm/types/queries/get.d.ts

@@ -0,0 +1,8 @@
+import { IEntityGetQuery } from "../abstractions/queries";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityGetQuery<TEntity, TEntityId> implements IEntityGetQuery<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(id: TEntityId): Promise<TEntity | undefined>;
+    private authorize;
+}

package/dist/esm/types/queries/search.d.ts

@@ -0,0 +1,10 @@
+import { SortingType } from "../abstractions/common";
+import { IEntitiesSearchQuery } from "../abstractions/queries";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { EntitiesSearchResults } from "../models";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntitiesSearchQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> implements IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+}

package/dist/esm/types/reflection/index.d.ts

@@ -0,0 +1 @@
+export declare const getTypeName: (type: any) => string;

package/dist/esm/types/services/connectors.d.ts

@@ -0,0 +1,13 @@
+import { IEntityConnectorDeleteManager, IEntityConnectorSyncManager } from "../abstractions/connectors";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityConnectorsManager<TEntity, TEntityId> implements IEntityConnectorSyncManager<TEntity>, IEntityConnectorDeleteManager<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    syncEntity(entity: TEntity): Promise<void>;
+    private processSync;
+    deleteEntity(entityId: TEntityId): Promise<void>;
+    private processDelete;
+    private resolveConnector;
+    private resolveMapper;
+    private getEnabledConnectors;
+}

package/dist/esm/types/services/events.d.ts

@@ -0,0 +1,9 @@
+import { IEntityEventsManager } from "../abstractions/events";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityEventsManager<TEntity, TEntityId> implements IEntityEventsManager<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    processEntityCreatedEvent(entity: TEntity): Promise<void>;
+    processEntityUpdatedEvent(entity: TEntity): Promise<void>;
+    processEntityDeletedEvent(id: TEntityId): Promise<void>;
+}

package/dist/esm/types/services/replication.d.ts

@@ -0,0 +1,12 @@
+import { IEntityReplicaDeleteManager, IEntityReplicaSyncManager } from "../abstractions/replication";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityReplicaManager<TEntity, TEntityId> implements IEntityReplicaSyncManager<TEntity>, IEntityReplicaDeleteManager<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    syncReplicas(entity: TEntity): Promise<void>;
+    private syncReplica;
+    deleteReplicas(entityId: TEntityId): Promise<void>;
+    private deleteReplica;
+    private getEnabledReplicas;
+    private resolveRepository;
+}

package/dist/esm/types/symbols/ioc.d.ts

@@ -0,0 +1,54 @@
+export declare const Services: {
+    Actions: {
+        IEntityGetAction: string;
+        IEntitiesSearchAction: string;
+        IEntityCreateAction: string;
+        IEntityUpdateAction: string;
+        IEntityUpsertAction: string;
+        IEntityDeleteAction: string;
+        IEntityMergeAction: string;
+    };
+    Authorization: {
+        IEntityAuthorizationMiddleware: string;
+    };
+    Commands: {
+        IEntityCreateCommand: string;
+        IEntityUpdateCommand: string;
+        IEntityUpsertCommand: string;
+        IEntityMergeCommand: string;
+        IEntityDeleteCommand: string;
+    };
+    Converters: {
+        IEntityCreateCommandConverter: string;
+        IEntityUpdateCommandConverter: string;
+        IEntitiesSearchConverter: string;
+        IEntityGetConverter: string;
+        IEntityCreateActionConverter: string;
+        IEntityUpdateActionConverter: string;
+    };
+    Connectors: {
+        IConnectorsConfiguration: string;
+        IEntityConnectorDeleteManager: string;
+        IEntityConnectorSyncManager: string;
+    };
+    Events: {
+        IEntityEventsManager: string;
+    };
+    Queries: {
+        IEntityGetQuery: string;
+        IEntitiesSearchQuery: string;
+        IEntitiesQueryBuilder: string;
+    };
+    Replication: {
+        IReplicasConfiguration: string;
+        IEntityReplicaDeleteManager: string;
+        IEntityReplicaSyncManager: string;
+    };
+    Services: {
+        IEntityActions: string;
+        IEntityManager: string;
+    };
+    Storage: {
+        IEntityRepository: string;
+    };
+};

package/dist/esm/types/testing/mocks/repository.d.ts

@@ -0,0 +1,20 @@
+import { FilterExpression } from "../../abstractions/filters";
+import { IEntityRepository } from "../../abstractions/repository";
+export declare class InMemoryRepository<TEntity> implements IEntityRepository<TEntity, string, FilterExpression<TEntity>, FilterExpression<TEntity>, FilterExpression<TEntity>, FilterExpression<TEntity>> {
+    private entities;
+    exists(id: string): Promise<boolean>;
+    existsBy(condition: FilterExpression<TEntity>): Promise<boolean>;
+    get(id: string): Promise<TEntity | undefined>;
+    getBy(condition: FilterExpression<TEntity>): Promise<TEntity | undefined>;
+    all(): Promise<TEntity[]>;
+    find(condition: FilterExpression<TEntity>): Promise<TEntity[]>;
+    findById(id: string[]): Promise<TEntity[]>;
+    delete(id: string): Promise<void>;
+    deleteBy(condition: FilterExpression<TEntity>): Promise<void>;
+    create(entity: TEntity): Promise<TEntity>;
+    update(id: string, entity: Partial<TEntity>): Promise<TEntity>;
+    updateBy(entity: Partial<TEntity>, condition: FilterExpression<TEntity>): Promise<TEntity[]>;
+    upsert(id: string, entity: TEntity): Promise<TEntity>;
+    private getId;
+    private filterEntities;
+}