@punks/backend-entity-manager 0.0.83 → 0.0.85

package/dist/esm/types/__test__/entity/foo.d.ts

@@ -5,9 +5,10 @@ import { IEntitySearchParameters } from "../../abstractions/searchParameters";
 import { IEntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
-import { IAuthenticationContext, IEntityManager } from "../../abstractions";
+import { EntitySerializerSheetDefinition, IAuthenticationContext, IEntityManager } from "../../abstractions";
 import { FooDeleteParameters } from "../providers/typeorm/entity/foo";
 import { IEntitiesDeleteResult } from "../../abstractions/repository";
+import { EntitySerializer } from "../../base";
 export interface FooEntity {
     id: string;
     name: string;
@@ -66,6 +67,9 @@ export interface FooUpdateDto {
         age: number;
     };
 }
+export declare class FooSerializer extends EntitySerializer<FooEntity> {
+    protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
+}
 export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateDto, FooUpdateDto> {
     toListItemDto(entity: FooEntity): FooListItemDto;
     toEntityDto(entity: FooEntity): FooDto;

package/dist/esm/types/__test__/providers/typeorm/entity/foo.d.ts

@@ -1,9 +1,10 @@
 import { DataSource, Repository, FindOptionsWhere } from "typeorm";
-import { IAuthenticationContext, IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirection } from "../../../../abstractions";
+import { EntitySerializerSheetDefinition, IAuthenticationContext, IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirection } from "../../../../abstractions";
 import { TypeOrmRepository } from "../../../../integrations/repository/typeorm";
 import { EntityServiceLocator } from "../../../../providers/services";
 import { TypeOrmQueryBuilder } from "../../../../integrations/repository/typeorm";
 import { IEntitiesDeleteParameters } from "../../../../abstractions/commands";
+import { EntitySerializer } from "../../../../base";
 export declare class FooEntity {
     id: string;
     name: string;
@@ -80,6 +81,9 @@ export declare class FooConverter implements IEntityConverter<FooEntity, FooDto,
     createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
     updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
 }
+export declare class FooSerializer extends EntitySerializer<FooEntity> {
+    protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
+}
 export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {
     useConverter?: boolean;
 }) => import("../../../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

package/dist/esm/types/abstractions/actions.d.ts

@@ -1,8 +1,10 @@
 import { IEntitiesSearchResults } from "../models";
 import { IEntitiesDeleteParameters } from "./commands";
 import { SortingType } from "./common";
-import { IEntityFacets } from "./queries";
+import { EntitiesExportInput, EntitiesExportResult, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult } from "./export";
+import { EntitiesImportInput, EntitiesImportResult } from "./import";
 import { IEntitySearchParameters, ISearchFilters } from "./searchParameters";
+import { IEntityFacets } from "./searchResults";
 export interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
     execute(input: TEntityCreateDto): Promise<TEntityDto>;
 }
@@ -30,6 +32,15 @@ export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEnti
 export interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
 }
+export interface IEntitiesExportAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor> {
+    execute(input: EntitiesExportInput<TEntitySearchParameters, TSorting, TCursor>): Promise<EntitiesExportResult>;
+}
+export interface IEntitiesImportAction<TEntity> {
+    execute(input: EntitiesImportInput): Promise<EntitiesImportResult>;
+}
+export interface IEntitiesSampleDownloadAction<TEntity> {
+    execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;
+}
 export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
     get search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
@@ -40,4 +51,7 @@ export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpd
     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 sampleDownload(): IEntitiesSampleDownloadAction<TEntity>;
 }

package/dist/esm/types/abstractions/buckets.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+export type BucketFolderListInput = {
+    bucket: string;
+    maxResults?: number;
+    path?: string;
+};
+export declare enum BucketItemType {
+    File = "file",
+    Folder = "folder"
+}
+export type BucketContentItem = {
+    type: BucketItemType;
+    name: string;
+    path: string;
+};
+export type BucketFolderContentResult = {
+    items: BucketContentItem[];
+};
+export type BucketFolderListResult = {};
+export type BucketFolderCreateInput = {
+    bucket: string;
+    path: string;
+};
+export type BucketFolderEnsureInput = {
+    bucket: string;
+    path: string;
+};
+export type BucketFolderExistsInput = {
+    bucket: string;
+    path: string;
+};
+export type BucketFileDownloadInput = {
+    bucket: string;
+    filePath: string;
+};
+export type BucketFilePublicUrlCreateInput = {
+    bucket: string;
+    filePath: string;
+    expirationMinutes: number;
+};
+export type BucketFileUploadInput = {
+    bucket: string;
+    filePath: string;
+    content: Buffer;
+    contentType?: string;
+};
+export interface BucketFileDeleteInput {
+    bucket: string;
+    filePath: string;
+}
+export interface IBucketProvider {
+    folderList(input: BucketFolderListInput): Promise<BucketFolderListResult>;
+    folderEnsure(input: BucketFolderEnsureInput): Promise<void>;
+    folderExists(input: BucketFolderExistsInput): Promise<boolean>;
+    fileDownload(input: BucketFileDownloadInput): Promise<Buffer>;
+    filePublicUrlCreate(input: BucketFilePublicUrlCreateInput): Promise<string>;
+    fileUpload(input: BucketFileUploadInput): Promise<void>;
+    fileDelete(input: BucketFileDeleteInput): Promise<void>;
+}

package/dist/esm/types/abstractions/commands.d.ts

@@ -1,4 +1,7 @@
-import { ISearchFilters, ISearchSorting } from "./searchParameters";
+import { SortingType } from "./common";
+import { EntitiesExportInput, EntitiesExportResult, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult } from "./export";
+import { EntitiesImportInput, EntitiesImportResult } from "./import";
+import { IEntitySearchParameters, ISearchFilters, ISearchSorting } from "./searchParameters";
 export interface IEntityCreateCommand<TEntity, TEntityCreateData> {
     execute(input: TEntityCreateData): Promise<TEntity>;
 }
@@ -21,3 +24,12 @@ export interface IEntitiesDeleteResult {
 export interface IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> {
     execute(params: TEntitiesDeleteParameters): Promise<IEntitiesDeleteResult>;
 }
+export interface IEntitiesExportCommand<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor> {
+    execute(input: EntitiesExportInput<TEntitySearchParameters, TSorting, TCursor>): Promise<EntitiesExportResult>;
+}
+export interface IEntitiesImportCommand<TEntity> {
+    execute(input: EntitiesImportInput): Promise<EntitiesImportResult>;
+}
+export interface IEntitiesSampleDownloadCommand<TEntity> {
+    execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;
+}

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

@@ -7,10 +7,17 @@ import { SortingType } from "./common";
 import { ConnectorOptions, IEntityConnector } from "./connectors";
 import { IEntityConverter } from "./converters";
 import { IEntityMapper } from "./mappers";
-import { IEntitiesQueryBuilder, IEntityFacets } from "./queries";
+import { IEntitiesQueryBuilder } from "./queries";
 import { ReplicaOptions } from "./replication";
 import { IEntityRepository } from "./repository";
 import { IEntitySearchParameters } from "./searchParameters";
+import { IEntityFacets } from "./searchResults";
+import { IEntitySerializer } from "./serializer";
+import { EntityManagerSettings } from "./settings";
+export type EntitiesMapOperationsInput<TEntitiesQueryBuilder> = {
+    queryBuilder: TEntitiesQueryBuilder;
+    settings: EntityManagerSettings;
+};
 export interface IEntityManagerServiceRoot {
     locator: ServiceLocator;
     getEntitiesServicesLocator(): EntitiesServiceLocator;
@@ -22,9 +29,8 @@ export interface IEntityManagerServiceRoot {
 }
 export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
     getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
-    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>({ queryBuilder, }: {
-        queryBuilder: TEntitiesQueryBuilder;
-    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>(input: EntitiesMapOperationsInput<TEntitiesQueryBuilder>): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addSerializer<TEntitySerializer extends IEntitySerializer<TEntity>>(serializer: TEntitySerializer): 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, }: {

package/dist/esm/types/abstractions/export.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { SortingType } from "./common";
+import { IEntitySearchParameters } from "./searchParameters";
+import { EntitySerializationFormat } from "./serializer";
+export type EntitiesExportOptions = {
+    format: EntitySerializationFormat;
+};
+export type EntitiesExportFile = {
+    name: string;
+    content: Buffer;
+    contentType: string;
+};
+export type EntitiesExportResult = {
+    file: EntitiesExportFile;
+    downloadUrl: string;
+};
+export type EntitiesExportInput<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor> = {
+    filters?: TEntitySearchParameters;
+    options: EntitiesExportOptions;
+};
+export type EntityExportBucketSettings = {
+    bucket: string;
+    publicLinksExpirationMinutes: number;
+    rootFolderPath?: string;
+};
+export type EntitiesImportExportSettings = {
+    exportBucket: EntityExportBucketSettings;
+};
+export type EntitiesSampleDownloadOptions = {
+    format: EntitySerializationFormat;
+};
+export type EntitiesSampleDownloadResult = {
+    file: EntitiesExportFile;
+};

package/dist/esm/types/abstractions/import.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { EntitySerializationFormat } from "./serializer";
+export type EntitiesImportInput = {
+    format: EntitySerializationFormat;
+    content: Buffer;
+};
+export type EntitiesImportStatistics = {
+    importedCount: number;
+    updatedCount: number;
+    createdCount: number;
+    unchangedCount: number;
+};
+export type EntitiesImportResult = {
+    statistics: EntitiesImportStatistics;
+};

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

@@ -1,22 +1,27 @@
-export { IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction, IEntitiesSearchAction, IEntityActions, } from "./actions";
+export { IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction, IEntitiesSearchAction, IEntityActions, IEntitiesCountAction, IEntitiesDeleteAction, IEntitiesExportAction, IEntitiesImportAction, IEntityExistsAction, IEntitiesSampleDownloadAction, } from "./actions";
 export { IEntityAdapter } from "./adapters";
 export * from "./authentication";
+export * from "./buckets";
 export { IAuthorizationResult, IEntityAuthorizationMiddleware, } from "./authorization";
-export { IEntityCreateCommand, IEntityUpdateCommand, IEntityUpsertCommand, IEntityDeleteCommand, IEntitiesDeleteParameters, } from "./commands";
-export { SortingType } from "./common";
+export { IEntityCreateCommand, IEntityUpdateCommand, IEntityUpsertCommand, IEntityDeleteCommand, IEntitiesImportCommand, IEntitiesExportCommand, IEntitiesDeleteParameters, IEntitiesDeleteCommand, IEntitiesDeleteResult, IEntitiesSampleDownloadCommand, } from "./commands";
+export { SortingType, ClassType, EnumType } from "./common";
 export { IEntityManagerServiceRoot, IEntityManagerServiceCollection, } from "./configuration";
 export { IEntityConverter } from "./converters";
 export * from "./email";
 export * from "./errors";
 export { IEntityEventsManager } from "./events";
+export { EntitiesExportFile, EntitiesExportInput, EntitiesExportOptions, EntitiesExportResult, EntitiesImportExportSettings, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult, EntityExportBucketSettings, } from "./export";
 export * from "./filters";
+export { EntitiesImportInput, EntitiesImportResult, EntitiesImportStatistics, } from "./import";
 export * from "./localization";
 export { IEntityManager } from "./manager";
 export { IEntityMapper } from "./mappers";
 export {} from "./pipelines";
-export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, IEntityFacet, IEntityFacets, IEntityFacetItem, IEntityExistsQuery, IEntitiesCountQuery, } from "./queries";
+export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, IEntityExistsQuery, IEntitiesCountQuery, } from "./queries";
 export { IReplicasConfiguration, ReplicationMode, ReplicaOptions, ReplicaConfiguration, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, } from "./replication";
 export { IEntityRepository } from "./repository";
 export * from "./searchParameters";
-export { IEntitySearchResults, ISearchResultsPaging } from "./searchResults";
+export { EntitySerializerColumnDefinition, EntitySerializerSheetDefinition, IEntitySerializer, EntitySerializationFormat, } from "./serializer";
+export { EntityManagerSettings } from "./settings";
+export { IEntitySearchResults, IEntityFacet, IEntityFacetItem, IEntityFacets, ISearchResultsPaging, } from "./searchResults";
 export * from "./tracking";

package/dist/esm/types/abstractions/manager.d.ts

@@ -1,7 +1,8 @@
-import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "./commands";
+import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesExportCommand, IEntitiesImportCommand, IEntitiesSampleDownloadCommand, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "./commands";
 import { SortingType } from "./common";
-import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityFacets, IEntityGetQuery } from "./queries";
+import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityGetQuery } from "./queries";
 import { IEntitySearchParameters } from "./searchParameters";
+import { IEntityFacets } from "./searchResults";
 export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     get get(): IEntityGetQuery<TEntity, TEntityId>;
     get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
@@ -12,4 +13,7 @@ export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUp
     get upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
     get delete(): IEntityDeleteCommand<TEntity, TEntityId>;
     get deleteItems(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
+    get import(): IEntitiesImportCommand<TEntity>;
+    get export(): IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>;
+    get sampleDownload(): IEntitiesSampleDownloadCommand<TEntity>;
 }

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

@@ -3,16 +3,7 @@ import { IAuthenticationContext } from "./authentication";
 import { SortingType } from "./common";
 import { IEntitiesDeleteResult } from "./repository";
 import { IEntitySearchParameters, ISearchFilters } from "./searchParameters";
-export interface IEntityFacetItem<T> {
-    value: T;
-    name?: string;
-    count?: number;
-}
-export interface IEntityFacet<T> {
-    items: IEntityFacetItem<T>[];
-}
-export interface IEntityFacets {
-}
+import { IEntityFacets } from "./searchResults";
 export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
 }

package/dist/esm/types/abstractions/searchResults.d.ts

@@ -1,5 +1,15 @@
 import { SortingType } from "./common";
 import { IEntitySearchParameters } from "./searchParameters";
+export interface IEntityFacetItem<T> {
+    value: T;
+    name?: string;
+    count?: number;
+}
+export interface IEntityFacet<T> {
+    items: IEntityFacetItem<T>[];
+}
+export interface IEntityFacets {
+}
 export interface IEntitySearchResults<TSearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> {
     request: TSearchParameters;
     items: TResult[];

package/dist/esm/types/abstractions/serializer.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+export type EntitySerializerColumnDefinition<TEntity> = {
+    name: string;
+    selector: keyof TEntity;
+    colSpan?: number;
+    sampleValue?: any;
+    parser?: (value: any) => any;
+    converter?: (value: any, item: TEntity) => any;
+};
+export type EntitySerializerSheetDefinition<TEntity> = {
+    columns: EntitySerializerColumnDefinition<TEntity>[];
+};
+export type EntityExportFile = {
+    content: Buffer;
+    contentType: string;
+    fileName: string;
+};
+export declare enum EntitySerializationFormat {
+    Csv = "csv",
+    Json = "json",
+    Xlsx = "xlsx"
+}
+export interface IEntitySerializer<TEntity> {
+    serialize(data: TEntity[], format: EntitySerializationFormat): Promise<EntityExportFile>;
+    parse(data: Buffer, format: EntitySerializationFormat): Promise<TEntity[]>;
+    createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
+}

package/dist/esm/types/abstractions/settings.d.ts

@@ -0,0 +1,4 @@
+import { EntitiesImportExportSettings } from "./export";
+export type EntityManagerSettings = {
+    importExport: EntitiesImportExportSettings;
+};

package/dist/esm/types/actions/export.d.ts

@@ -0,0 +1,11 @@
+import { IEntitiesExportAction } from "../abstractions/actions";
+import { EntityServiceLocator } from "../providers/services";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { SortingType } from "../abstractions/common";
+import { EntitiesExportInput } from "../abstractions/export";
+export declare class EntitiesExportAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor> implements IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor> {
+    private readonly services;
+    private readonly logger;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(input: EntitiesExportInput<TEntitySearchParameters, TSorting, TCursor>): Promise<import("../abstractions/export").EntitiesExportResult>;
+}

package/dist/esm/types/actions/import.d.ts

@@ -0,0 +1,9 @@
+import { IEntitiesImportAction } from "../abstractions/actions";
+import { EntityServiceLocator } from "../providers/services";
+import { EntitiesImportInput } from "../abstractions/import";
+export declare class EntitiesImportAction<TEntity> implements IEntitiesImportAction<TEntity> {
+    private readonly services;
+    private readonly logger;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(input: EntitiesImportInput): Promise<import("../abstractions/import").EntitiesImportResult>;
+}

package/dist/esm/types/actions/sampleDownload.d.ts

@@ -0,0 +1,9 @@
+import { EntityServiceLocator } from "../providers/services";
+import { IEntitiesSampleDownloadAction } from "../abstractions/actions";
+import { EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult } from "../abstractions";
+export declare class EntitiesSampleDownloadAction<TEntity> implements IEntitiesSampleDownloadAction<TEntity> {
+    private readonly services;
+    private readonly logger;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;
+}

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

@@ -1 +1,2 @@
 export { EntitySeeder } from "./seed";
+export { EntitySerializer } from "./serializer";

package/dist/esm/types/base/serializer.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { EntitySerializationFormat, IEntitySerializer } from "../abstractions";
+import { EntityExportFile, EntitySerializerSheetDefinition } from "../abstractions/serializer";
+import { EntityServiceLocator } from "../providers/services";
+export declare abstract class EntitySerializer<TEntity> implements IEntitySerializer<TEntity> {
+    protected readonly services: EntityServiceLocator<TEntity, unknown>;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    parse(data: Buffer, format: EntitySerializationFormat): Promise<TEntity[]>;
+    createSample(format: EntitySerializationFormat): Promise<EntityExportFile>;
+    private buildSampleFile;
+    serialize(data: TEntity[], format: EntitySerializationFormat): Promise<EntityExportFile>;
+    protected abstract getDefinition(): EntitySerializerSheetDefinition<TEntity>;
+    private buildExportFile;
+    private getColumnValue;
+    private buildExportFileName;
+}

package/dist/esm/types/commands/export.d.ts

@@ -0,0 +1,17 @@
+import { EntitiesExportInput, EntitiesExportResult, EntitiesImportExportSettings } from "../abstractions";
+import { IEntitiesExportCommand } from "../abstractions/commands";
+import { SortingType } from "../abstractions/common";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { EntityServiceLocator } from "../providers/services";
+export declare const createDayPath: (d: Date) => string;
+export declare class EntitiesExportCommand<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor> implements IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor> {
+    private readonly services;
+    private readonly settings;
+    constructor(services: EntityServiceLocator<TEntity, unknown>, settings: EntitiesImportExportSettings);
+    execute(input: EntitiesExportInput<TEntitySearchParameters, TSorting, TCursor>): Promise<EntitiesExportResult>;
+    private buildExportFile;
+    private uploadExportFile;
+    private buildAbsoluteBucketPath;
+    private getExportEntities;
+    private get bucket();
+}

package/dist/esm/types/commands/import.d.ts

@@ -0,0 +1,10 @@
+import { EntitiesImportInput, EntitiesImportResult } from "../abstractions/import";
+import { IEntitiesImportCommand } from "../abstractions/commands";
+import { EntityServiceLocator } from "../providers/services";
+import { EntitiesImportExportSettings } from "../abstractions";
+export declare class EntitiesImportCommand<TEntity> implements IEntitiesImportCommand<TEntity> {
+    private readonly services;
+    private readonly settings;
+    constructor(services: EntityServiceLocator<TEntity, unknown>, settings: EntitiesImportExportSettings);
+    execute(input: EntitiesImportInput): Promise<EntitiesImportResult>;
+}

package/dist/esm/types/commands/sampleDownload.d.ts

@@ -0,0 +1,8 @@
+import { IEntitiesSampleDownloadCommand } from "../abstractions/commands";
+import { EntityServiceLocator } from "../providers/services";
+import { EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult } from "../abstractions";
+export declare class EntitiesSampleDownloadCommand<TEntity> implements IEntitiesSampleDownloadCommand<TEntity> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(input: EntitiesSampleDownloadOptions): Promise<EntitiesSampleDownloadResult>;
+}

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

@@ -1,9 +1,10 @@
-import { IEntitiesCountAction, IEntitiesDeleteAction, IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityExistsAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
-import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
+import { IEntitiesCountAction, IEntitiesDeleteAction, IEntitiesExportAction, IEntitiesImportAction, IEntitiesSampleDownloadAction, IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityExistsAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
+import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesExportCommand, IEntitiesImportCommand, IEntitiesSampleDownloadCommand, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
 import { SortingType } from "../abstractions/common";
 import { IEntityManager } from "../abstractions/manager";
-import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
+import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityGetQuery } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { IEntityFacets } from "../abstractions/searchResults";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
@@ -17,6 +18,9 @@ export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntit
     get update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
     get upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
     get delete(): IEntityDeleteCommand<TEntity, TEntityId>;
+    get export(): IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>;
+    get import(): IEntitiesImportCommand<TEntity>;
+    get sampleDownload(): IEntitiesSampleDownloadCommand<TEntity>;
 }
 export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
@@ -30,4 +34,7 @@ export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntity
     get update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
     get upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
     get delete(): IEntityDeleteAction<TEntity, TEntityId>;
+    get export(): IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor>;
+    get import(): IEntitiesImportAction<TEntity>;
+    get sampleDownload(): IEntitiesSampleDownloadAction<TEntity>;
 }

package/dist/esm/types/platforms/nest/__test__/server/app/appCompanies/appCompany.actions.d.ts

@@ -0,0 +1,7 @@
+import { EntityManagerRegistry, NestEntityActions } from "../../../../../..";
+import { AppCompanyCreateDto, AppCompanyDto, AppCompanyListItemDto, AppCompanyUpdateDto } from "./appCompany.dto";
+import { AppCompanyEntity } from "../../database/core/entities/appCompany.entity";
+import { AppCompanyCursor, AppCompanyDeleteParameters, AppCompanyEntityId, AppCompanyFacets, AppCompanySearchParameters, AppCompanySorting } from "../../entities/appCompanies/appCompany.models";
+export declare class AppCompanyActions extends NestEntityActions<AppCompanyEntity, AppCompanyEntityId, AppCompanyCreateDto, AppCompanyUpdateDto, AppCompanyDto, AppCompanyListItemDto, AppCompanyDeleteParameters, AppCompanySearchParameters, AppCompanySorting, AppCompanyCursor, AppCompanyFacets> {
+    constructor(registry: EntityManagerRegistry);
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appCompanies/appCompany.controller.d.ts

@@ -0,0 +1,11 @@
+import { AppCompanyActions } from "./appCompany.actions";
+import { AppCompanyCreateDto, AppCompanyDto, AppCompanySearchRequest, AppCompanySearchResponse, AppCompanyUpdateDto } from "./appCompany.dto";
+export declare class AppCompanyController {
+    private readonly actions;
+    constructor(actions: AppCompanyActions);
+    item(id: string): Promise<AppCompanyDto | undefined>;
+    create(data: AppCompanyCreateDto): Promise<AppCompanyDto>;
+    update(id: string, item: AppCompanyUpdateDto): Promise<AppCompanyDto>;
+    delete(id: string): Promise<void>;
+    search(request: AppCompanySearchRequest): Promise<AppCompanySearchResponse>;
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appCompanies/appCompany.converter.d.ts

@@ -0,0 +1,9 @@
+import { IEntityConverter } from "../../../../../..";
+import { AppCompanyCreateDto, AppCompanyDto, AppCompanyListItemDto, AppCompanyUpdateDto } from "./appCompany.dto";
+import { AppCompanyEntity } from "../../database/core/entities/appCompany.entity";
+export declare class AppCompanyConverter implements IEntityConverter<AppCompanyEntity, AppCompanyDto, AppCompanyListItemDto, AppCompanyCreateDto, AppCompanyUpdateDto> {
+    toListItemDto(entity: AppCompanyEntity): AppCompanyListItemDto;
+    toEntityDto(entity: AppCompanyEntity): AppCompanyDto;
+    createDtoToEntity(input: AppCompanyCreateDto): Partial<AppCompanyEntity>;
+    updateDtoToEntity(input: AppCompanyUpdateDto): Partial<AppCompanyEntity>;
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appCompanies/appCompany.dto.d.ts

@@ -0,0 +1,20 @@
+import { AppCompanySearchParameters, AppCompanySearchResults } from "../../entities/appCompanies/appCompany.models";
+export declare class AppCompanyDto {
+    id: string;
+    createdOn: Date;
+    updatedOn: Date;
+}
+export declare class AppCompanyListItemDto {
+    id: string;
+}
+export declare class AppCompanyCreateDto {
+}
+export declare class AppCompanyUpdateDto {
+    id: string;
+}
+export declare class AppCompanySearchRequest {
+    params: AppCompanySearchParameters;
+}
+export declare class AppCompanySearchResponse extends AppCompanySearchResults<AppCompanyListItemDto> {
+    items: AppCompanyListItemDto[];
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appCompanies/appCompany.module.d.ts

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

package/dist/esm/types/platforms/nest/__test__/server/app/appCompanies/appCompany.serializer.d.ts

@@ -0,0 +1,6 @@
+import { NestEntitySerializer } from "../../../../base";
+import { EntitySerializerSheetDefinition } from "../../../../../../abstractions";
+import { AppCompanyEntity } from "../../database/core/entities/appCompany.entity";
+export declare class AppCompanySerializer extends NestEntitySerializer<AppCompanyEntity> {
+    protected getDefinition(): EntitySerializerSheetDefinition<AppCompanyEntity>;
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appDivisions/appDivision.actions.d.ts

@@ -0,0 +1,7 @@
+import { EntityManagerRegistry, NestEntityActions } from "../../../../../..";
+import { AppDivisionCreateDto, AppDivisionDto, AppDivisionListItemDto, AppDivisionUpdateDto } from "./appDivision.dto";
+import { AppDivisionEntity } from "../../database/core/entities/appDivision.entity";
+import { AppDivisionCursor, AppDivisionDeleteParameters, AppDivisionEntityId, AppDivisionFacets, AppDivisionSearchParameters, AppDivisionSorting } from "../../entities/appDivisions/appDivision.models";
+export declare class AppDivisionActions extends NestEntityActions<AppDivisionEntity, AppDivisionEntityId, AppDivisionCreateDto, AppDivisionUpdateDto, AppDivisionDto, AppDivisionListItemDto, AppDivisionDeleteParameters, AppDivisionSearchParameters, AppDivisionSorting, AppDivisionCursor, AppDivisionFacets> {
+    constructor(registry: EntityManagerRegistry);
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appDivisions/appDivision.controller.d.ts

@@ -0,0 +1,11 @@
+import { AppDivisionActions } from "./appDivision.actions";
+import { AppDivisionCreateDto, AppDivisionDto, AppDivisionSearchRequest, AppDivisionSearchResponse, AppDivisionUpdateDto } from "./appDivision.dto";
+export declare class AppDivisionController {
+    private readonly actions;
+    constructor(actions: AppDivisionActions);
+    item(id: string): Promise<AppDivisionDto | undefined>;
+    create(data: AppDivisionCreateDto): Promise<AppDivisionDto>;
+    update(id: string, item: AppDivisionUpdateDto): Promise<AppDivisionDto>;
+    delete(id: string): Promise<void>;
+    search(request: AppDivisionSearchRequest): Promise<AppDivisionSearchResponse>;
+}

package/dist/esm/types/platforms/nest/__test__/server/app/appDivisions/appDivision.converter.d.ts

@@ -0,0 +1,9 @@
+import { IEntityConverter } from "../../../../../..";
+import { AppDivisionCreateDto, AppDivisionDto, AppDivisionListItemDto, AppDivisionUpdateDto } from "./appDivision.dto";
+import { AppDivisionEntity } from "../../database/core/entities/appDivision.entity";
+export declare class AppDivisionConverter implements IEntityConverter<AppDivisionEntity, AppDivisionDto, AppDivisionListItemDto, AppDivisionCreateDto, AppDivisionUpdateDto> {
+    toListItemDto(entity: AppDivisionEntity): AppDivisionListItemDto;
+    toEntityDto(entity: AppDivisionEntity): AppDivisionDto;
+    createDtoToEntity(input: AppDivisionCreateDto): Partial<AppDivisionEntity>;
+    updateDtoToEntity(input: AppDivisionUpdateDto): Partial<AppDivisionEntity>;
+}