@infrab4a/connect 4.24.0 → 4.24.1-beta.1

package/src/domain/general/models/log-document.d.ts

@@ -1,15 +1,15 @@
-import { BaseModel, GenericIdentifier } from '../../generic';
-export declare class LogDocument extends BaseModel<LogDocument> {
-    id?: string;
-    collection: string;
-    documentId: string;
-    user?: {
-        id?: string;
-        name?: string;
-        email?: string;
-    };
-    document: any;
-    date: Date;
-    operation: 'CREATE' | 'UPDATE' | 'DELETE';
-    static get identifiersFields(): GenericIdentifier[];
-}
+import { BaseModel, GenericIdentifier } from '../../generic';
+export declare class LogDocument extends BaseModel<LogDocument> {
+    id?: string;
+    collection: string;
+    documentId: string;
+    user?: {
+        id?: string;
+        name?: string;
+        email?: string;
+    };
+    document: any;
+    date: Date;
+    operation: 'CREATE' | 'UPDATE' | 'DELETE';
+    static get identifiersFields(): GenericIdentifier[];
+}

package/src/domain/general/models/sequences.d.ts

@@ -1,9 +1,9 @@
-import { BaseModel, GenericIdentifier } from '../../generic';
-export declare class Sequence extends BaseModel<Sequence> {
-    id?: string;
-    type: string;
-    counter: number;
-    month: number;
-    year: number;
-    static get identifiersFields(): GenericIdentifier[];
-}
+import { BaseModel, GenericIdentifier } from '../../generic';
+export declare class Sequence extends BaseModel<Sequence> {
+    id?: string;
+    type: string;
+    counter: number;
+    month: number;
+    year: number;
+    static get identifiersFields(): GenericIdentifier[];
+}

package/src/domain/general/repositories/index.d.ts

@@ -1,2 +1,2 @@
-export * from './log.repository';
-export * from './sequences.repository';
+export * from './log.repository';
+export * from './sequences.repository';

package/src/domain/general/repositories/log.repository.d.ts

@@ -1,4 +1,4 @@
-import { CrudRepository } from '../../generic/repository/crud.repository';
-import { LogDocument } from '../models';
-export interface LogRepository extends CrudRepository<LogDocument> {
-}
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { LogDocument } from '../models';
+export interface LogRepository extends CrudRepository<LogDocument> {
+}

package/src/domain/general/repositories/sequences.repository.d.ts

@@ -1,4 +1,4 @@
-import { CrudRepository } from '../../generic/repository/crud.repository';
-import { Sequence } from '../models';
-export interface SequenceRepository extends CrudRepository<Sequence> {
-}
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Sequence } from '../models';
+export interface SequenceRepository extends CrudRepository<Sequence> {
+}

package/src/domain/general/search/index.d.ts

@@ -1 +1 @@
-export * from './product-search-index';
+export * from './product-search-index';

package/src/domain/general/search/product-search-index.d.ts

@@ -1,3 +1,3 @@
-export interface ProductSearchIndex {
-    search<T>(searchTerm: string, total: number, gender?: String): Promise<T[]>;
-}
+export interface ProductSearchIndex {
+    search<T>(searchTerm: string, total: number, gender?: String): Promise<T[]>;
+}

package/src/domain/general/storage/file-uploader.service.d.ts

@@ -1,3 +1,3 @@
-export interface FileUploaderService {
-    upload(url: string, file: Blob | Uint8Array | ArrayBuffer): Promise<string>;
-}
+export interface FileUploaderService {
+    upload(url: string, file: Blob | Uint8Array | ArrayBuffer): Promise<string>;
+}

package/src/domain/general/storage/index.d.ts

@@ -1 +1 @@
-export * from './file-uploader.service';
+export * from './file-uploader.service';

package/src/domain/generic/index.d.ts

@@ -1,2 +1,2 @@
-export * from './model';
-export * from './repository';
+export * from './model';
+export * from './repository';

package/src/domain/generic/model/base.model.d.ts

@@ -1,14 +1,14 @@
-import { ModelBaseStructure, NonFunctionAndIdentifierProperties, NonFunctionAndIdentifierPropertyNames } from './types';
-export type GenericIdentifier<M = {
-    id: string;
-}, T = NonFunctionAndIdentifierPropertyNames<M>> = T;
-export declare class BaseModel<Model extends ModelBaseStructure<Model, Identifiers>, Identifiers = GenericIdentifier> implements ModelBaseStructure<Model, Identifiers> {
-    get identifier(): {
-        [key in Extract<NonFunctionAndIdentifierPropertyNames<Model>, Identifiers>]: Model[key];
-    };
-    get identifiersFields(): Identifiers[];
-    constructor(args?: Partial<Model>);
-    static toInstance<T>(this: new () => T, data?: Partial<NonFunctionAndIdentifierProperties<T>>): T;
-    static isModel<T extends ModelBaseStructure>(this: new () => T, value: any): value is T;
-    toPlain(): any;
-}
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, NonFunctionAndIdentifierPropertyNames } from './types';
+export type GenericIdentifier<M = {
+    id: string;
+}, T = NonFunctionAndIdentifierPropertyNames<M>> = T;
+export declare class BaseModel<Model extends ModelBaseStructure<Model, Identifiers>, Identifiers = GenericIdentifier> implements ModelBaseStructure<Model, Identifiers> {
+    get identifier(): {
+        [key in Extract<NonFunctionAndIdentifierPropertyNames<Model>, Identifiers>]: Model[key];
+    };
+    get identifiersFields(): Identifiers[];
+    constructor(args?: Partial<Model>);
+    static toInstance<T>(this: new () => T, data?: Partial<NonFunctionAndIdentifierProperties<T>>): T;
+    static isModel<T extends ModelBaseStructure>(this: new () => T, value: any): value is T;
+    toPlain(): any;
+}

package/src/domain/generic/model/identifier-fields.d.ts

@@ -1,4 +1,4 @@
-import { NonFunctionPropertyNames } from './types/non-function-property-name.type';
-export interface IdentifierFields<Model> {
-    identifierFields: () => NonFunctionPropertyNames<Model>[];
-}
+import { NonFunctionPropertyNames } from './types/non-function-property-name.type';
+export interface IdentifierFields<Model> {
+    identifierFields: () => NonFunctionPropertyNames<Model>[];
+}

package/src/domain/generic/model/index.d.ts

@@ -1,3 +1,3 @@
-export * from './base.model';
-export * from './identifier-fields';
-export * from './types';
+export * from './base.model';
+export * from './identifier-fields';
+export * from './types';

package/src/domain/generic/model/types/base-model-builder.type.d.ts

@@ -1,17 +1,17 @@
-import { PartialIdentifiersModel } from './identifier-model.type';
-import { ModelBaseStructure } from './model-base-structure.type';
-import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
-import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
-export interface BaseModelBuilder<T extends ModelBaseStructure<T>, Identifiers = NonFunctionAndIdentifierPropertyNames<T> | any, P extends T & {
-    prototype: unknown;
-} = T & {
-    prototype: unknown;
-}> {
-    new (...args: any[]): T;
-    identifiersFields: Identifiers[];
-    prototype: {
-        [key in keyof P['prototype']]: P['prototype'][key];
-    };
-    toInstance<E>(this: new () => E, data?: NonFunctionAndIdentifierPropertiesWithNoPartial<T> | PartialIdentifiersModel<T>): E;
-    isModel(model: any): model is T;
-}
+import { PartialIdentifiersModel } from './identifier-model.type';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
+import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
+export interface BaseModelBuilder<T extends ModelBaseStructure<T>, Identifiers = NonFunctionAndIdentifierPropertyNames<T> | any, P extends T & {
+    prototype: unknown;
+} = T & {
+    prototype: unknown;
+}> {
+    new (...args: any[]): T;
+    identifiersFields: Identifiers[];
+    prototype: {
+        [key in keyof P['prototype']]: P['prototype'][key];
+    };
+    toInstance<E>(this: new () => E, data?: NonFunctionAndIdentifierPropertiesWithNoPartial<T> | PartialIdentifiersModel<T>): E;
+    isModel(model: any): model is T;
+}

package/src/domain/generic/model/types/identifier-model.type.d.ts

@@ -1,8 +1,8 @@
-import { PropType } from '../../../../utils';
-import { ModelBaseStructure } from './model-base-structure.type';
-import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
-export type IdentifierModel<Model extends ModelBaseStructure> = Extract<NonFunctionAndIdentifierPropertyNames<Model>, PropType<Model, 'identifiersFields'>[number]>;
-export type IdentifiersModel<Model extends ModelBaseStructure> = {
-    [K in IdentifierModel<Model>]: Model[K];
-};
-export type PartialIdentifiersModel<Model extends ModelBaseStructure> = Partial<IdentifiersModel<Model>>;
+import { PropType } from '../../../../utils';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
+export type IdentifierModel<Model extends ModelBaseStructure> = Extract<NonFunctionAndIdentifierPropertyNames<Model>, PropType<Model, 'identifiersFields'>[number]>;
+export type IdentifiersModel<Model extends ModelBaseStructure> = {
+    [K in IdentifierModel<Model>]: Model[K];
+};
+export type PartialIdentifiersModel<Model extends ModelBaseStructure> = Partial<IdentifiersModel<Model>>;

package/src/domain/generic/model/types/index.d.ts

@@ -1,5 +1,5 @@
-export * from './non-function-property-name.type';
-export * from './non-function-properties.type';
-export * from './base-model-builder.type';
-export * from './model-base-structure.type';
-export * from './identifier-model.type';
+export * from './non-function-property-name.type';
+export * from './non-function-properties.type';
+export * from './base-model-builder.type';
+export * from './model-base-structure.type';
+export * from './identifier-model.type';

package/src/domain/generic/model/types/model-base-structure.type.d.ts

@@ -1,12 +1,12 @@
-import { NonFunctionAndIdentifierPropertyNames } from '..';
-type ModelBaseStructureRecord = Record<string, any> & {
-    identifiersFields: any[];
-};
-export type ModelBaseStructure<M extends ModelBaseStructureRecord = ModelBaseStructureRecord, I = M['identifiersFields'][number]> = {
-    identifier: {
-        [key in Extract<NonFunctionAndIdentifierPropertyNames<M>, I>]: M[key];
-    };
-    identifiersFields: I[];
-    toPlain: any;
-};
-export {};
+import { NonFunctionAndIdentifierPropertyNames } from '..';
+type ModelBaseStructureRecord = Record<string, any> & {
+    identifiersFields: any[];
+};
+export type ModelBaseStructure<M extends ModelBaseStructureRecord = ModelBaseStructureRecord, I = M['identifiersFields'][number]> = {
+    identifier: {
+        [key in Extract<NonFunctionAndIdentifierPropertyNames<M>, I>]: M[key];
+    };
+    identifiersFields: I[];
+    toPlain: any;
+};
+export {};

package/src/domain/generic/model/types/non-function-properties.type.d.ts

@@ -1,12 +1,12 @@
-import { PropType } from '../../../../utils';
-import { IdentifierModel, PartialIdentifiersModel } from './identifier-model.type';
-import { ModelBaseStructure } from './model-base-structure.type';
-import { NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from './non-function-property-name.type';
-export type NonFunctionProperties<T> = Pick<Partial<T>, NonFunctionPropertyNames<T>>;
-export type NonFunctionAndIdentifierProperties<T> = Pick<Partial<T>, NonFunctionAndIdentifierPropertyNames<T>>;
-export type NonFunctionAndIdentifierPropertiesWithNoPartial<T> = Pick<T, NonFunctionAndIdentifierPropertyNames<T>>;
-export type NonFunctionAndIdentifierPropertiesWithNoModels<T> = {
-    [key in keyof NonFunctionAndIdentifierPropertiesWithNoPartial<T>]: PropType<T, key> extends ModelBaseStructure ? NonFunctionAndIdentifierPropertiesWithNoIdentifiers<PropType<T, key>> & PartialIdentifiersModel<PropType<T, key>> : PropType<T, key> extends ModelBaseStructure[] ? PropType<T, key>[] : PropType<T, key>;
-};
-export type NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> = Omit<NonFunctionAndIdentifierPropertiesWithNoModels<T>, T extends ModelBaseStructure ? IdentifierModel<T> : never>;
-export type NonFunctionAndIdentifierPropertiesWithPartialIdentifiers<T> = NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> & (T extends ModelBaseStructure ? PartialIdentifiersModel<T> : never);
+import { PropType } from '../../../../utils';
+import { IdentifierModel, PartialIdentifiersModel } from './identifier-model.type';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from './non-function-property-name.type';
+export type NonFunctionProperties<T> = Pick<Partial<T>, NonFunctionPropertyNames<T>>;
+export type NonFunctionAndIdentifierProperties<T> = Pick<Partial<T>, NonFunctionAndIdentifierPropertyNames<T>>;
+export type NonFunctionAndIdentifierPropertiesWithNoPartial<T> = Pick<T, NonFunctionAndIdentifierPropertyNames<T>>;
+export type NonFunctionAndIdentifierPropertiesWithNoModels<T> = {
+    [key in keyof NonFunctionAndIdentifierPropertiesWithNoPartial<T>]: PropType<T, key> extends ModelBaseStructure ? NonFunctionAndIdentifierPropertiesWithNoIdentifiers<PropType<T, key>> & PartialIdentifiersModel<PropType<T, key>> : PropType<T, key> extends ModelBaseStructure[] ? PropType<T, key>[] : PropType<T, key>;
+};
+export type NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> = Omit<NonFunctionAndIdentifierPropertiesWithNoModels<T>, T extends ModelBaseStructure ? IdentifierModel<T> : never>;
+export type NonFunctionAndIdentifierPropertiesWithPartialIdentifiers<T> = NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> & (T extends ModelBaseStructure ? PartialIdentifiersModel<T> : never);

package/src/domain/generic/model/types/non-function-property-name.type.d.ts

@@ -1,13 +1,13 @@
-export type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
-export type ReadonlyKeys<T> = {
-    [P in keyof T]-?: IfEquals<{
-        [Q in P]: T[P];
-    }, {
-        -readonly [Q in P]: T[P];
-    }, never, P>;
-}[keyof T];
-export type WritableKeys<T> = Exclude<keyof T, ReadonlyKeys<T>>;
-export type NonFunctionPropertyNames<T, P = T, E extends WritableKeys<P> = WritableKeys<P>> = {
-    [K in E]: P[K] extends Function ? never : K extends 'identifiersFields' ? never : K;
-}[E];
-export type NonFunctionAndIdentifierPropertyNames<T> = NonFunctionPropertyNames<Omit<T, 'identifier' | 'identifiersFields'>>;
+export type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
+export type ReadonlyKeys<T> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, never, P>;
+}[keyof T];
+export type WritableKeys<T> = Exclude<keyof T, ReadonlyKeys<T>>;
+export type NonFunctionPropertyNames<T, P = T, E extends WritableKeys<P> = WritableKeys<P>> = {
+    [K in E]: P[K] extends Function ? never : K extends 'identifiersFields' ? never : K;
+}[E];
+export type NonFunctionAndIdentifierPropertyNames<T> = NonFunctionPropertyNames<Omit<T, 'identifier' | 'identifiersFields'>>;

package/src/domain/generic/repository/create.repository.d.ts

@@ -1,8 +1,8 @@
-import { PropType } from '../../../utils';
-import { ModelBaseStructure, NonFunctionAndIdentifierProperties, PartialIdentifiersModel } from '../model/types';
-export type CreateRepositoryParams<Model extends ModelBaseStructure> = {
-    [key in keyof NonFunctionAndIdentifierProperties<Model>]: PropType<Model, key> extends ModelBaseStructure ? CreateRepositoryParams<PropType<Model, key>> : PropType<Model, key>;
-} & PartialIdentifiersModel<Model>;
-export interface CreateRepository<Model extends ModelBaseStructure, Params = CreateRepositoryParams<Model>> {
-    create(data: Params): Promise<Model>;
-}
+import { PropType } from '../../../utils';
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, PartialIdentifiersModel } from '../model/types';
+export type CreateRepositoryParams<Model extends ModelBaseStructure> = {
+    [key in keyof NonFunctionAndIdentifierProperties<Model>]: PropType<Model, key> extends ModelBaseStructure ? CreateRepositoryParams<PropType<Model, key>> : PropType<Model, key>;
+} & PartialIdentifiersModel<Model>;
+export interface CreateRepository<Model extends ModelBaseStructure, Params = CreateRepositoryParams<Model>> {
+    create(data: Params): Promise<Model>;
+}

package/src/domain/generic/repository/crud.repository.d.ts

@@ -1,19 +1,19 @@
-import { ModelBaseStructure } from '../model/types/model-base-structure.type';
-import { CreateRepository, CreateRepositoryParams } from './create.repository';
-import { DeleteRepository, DeleteRepositoryParams } from './delete.repository';
-import { ReadRepository, ReadRepositoryParams } from './read.repository';
-import { UpdateRepository, UpdateRepositoryParams } from './update.repository';
-export type CrudGenericParams = {
-    Create?: any;
-    Delete?: any;
-    Read?: ReadRepositoryParams<any>;
-    Update?: any;
-};
-export type CrudParams<Model extends ModelBaseStructure> = {
-    Create?: CreateRepositoryParams<Model>;
-    Delete?: DeleteRepositoryParams<Model>;
-    Read?: ReadRepositoryParams<Model>;
-    Update?: UpdateRepositoryParams<Model>;
-};
-export interface CrudRepository<Model extends ModelBaseStructure, Params extends CrudGenericParams = CrudParams<Model>> extends CreateRepository<Model, CreateRepositoryParams<Model> & Params['Create']>, DeleteRepository<Model, DeleteRepositoryParams<Model> & Params['Delete']>, ReadRepository<Model, ReadRepositoryParams<Model> & Params['Read']>, UpdateRepository<Model, UpdateRepositoryParams<Model> & Params['Update']> {
-}
+import { ModelBaseStructure } from '../model/types/model-base-structure.type';
+import { CreateRepository, CreateRepositoryParams } from './create.repository';
+import { DeleteRepository, DeleteRepositoryParams } from './delete.repository';
+import { ReadRepository, ReadRepositoryParams } from './read.repository';
+import { UpdateRepository, UpdateRepositoryParams } from './update.repository';
+export type CrudGenericParams = {
+    Create?: any;
+    Delete?: any;
+    Read?: ReadRepositoryParams<any>;
+    Update?: any;
+};
+export type CrudParams<Model extends ModelBaseStructure> = {
+    Create?: CreateRepositoryParams<Model>;
+    Delete?: DeleteRepositoryParams<Model>;
+    Read?: ReadRepositoryParams<Model>;
+    Update?: UpdateRepositoryParams<Model>;
+};
+export interface CrudRepository<Model extends ModelBaseStructure, Params extends CrudGenericParams = CrudParams<Model>> extends CreateRepository<Model, CreateRepositoryParams<Model> & Params['Create']>, DeleteRepository<Model, DeleteRepositoryParams<Model> & Params['Delete']>, ReadRepository<Model, ReadRepositoryParams<Model> & Params['Read']>, UpdateRepository<Model, UpdateRepositoryParams<Model> & Params['Update']> {
+}

package/src/domain/generic/repository/delete.repository.d.ts

@@ -1,7 +1,7 @@
-import { IdentifiersModel, ModelBaseStructure } from '../model/types';
-export type DeleteRepositoryParams<Model extends ModelBaseStructure> = {
-    [K in keyof IdentifiersModel<Model>]: Model[K] | null;
-};
-export interface DeleteRepository<Model extends ModelBaseStructure, Params = DeleteRepositoryParams<Model>> {
-    delete(identifiers: Params): Promise<void>;
-}
+import { IdentifiersModel, ModelBaseStructure } from '../model/types';
+export type DeleteRepositoryParams<Model extends ModelBaseStructure> = {
+    [K in keyof IdentifiersModel<Model>]: Model[K] | null;
+};
+export interface DeleteRepository<Model extends ModelBaseStructure, Params = DeleteRepositoryParams<Model>> {
+    delete(identifiers: Params): Promise<void>;
+}

package/src/domain/generic/repository/enums/index.d.ts

@@ -1,2 +1,2 @@
-export * from './where.enum';
-export * from './update-option-actions.enum';
+export * from './where.enum';
+export * from './update-option-actions.enum';

package/src/domain/generic/repository/enums/update-option-actions.enum.d.ts

@@ -1,7 +1,7 @@
-export declare enum UpdateOptionActions {
-    UPDATE = "update",
-    MERGE = "merge",
-    REMOVE = "remove",
-    REMOVE_FIELD = "removeField",
-    NULL = "null"
-}
+export declare enum UpdateOptionActions {
+    UPDATE = "update",
+    MERGE = "merge",
+    REMOVE = "remove",
+    REMOVE_FIELD = "removeField",
+    NULL = "null"
+}

package/src/domain/generic/repository/enums/where.enum.d.ts

@@ -1,15 +1,15 @@
-export declare enum Where {
-    EQUALS = "==",
-    NOTEQUALS = "!=",
-    GT = ">",
-    GTE = ">=",
-    IN = "in",
-    NOTIN = "not in",
-    LT = "<",
-    LTE = "<=",
-    LIKE = "like",
-    NOTLIKE = "not like",
-    ISNULL = "is null",
-    ISNOTNULL = "is not null",
-    IREGEX = "iregex"
-}
+export declare enum Where {
+    EQUALS = "==",
+    NOTEQUALS = "!=",
+    GT = ">",
+    GTE = ">=",
+    IN = "in",
+    NOTIN = "not in",
+    LT = "<",
+    LTE = "<=",
+    LIKE = "like",
+    NOTLIKE = "not like",
+    ISNULL = "is null",
+    ISNOTNULL = "is not null",
+    IREGEX = "iregex"
+}

package/src/domain/generic/repository/find.repository.d.ts

@@ -1,17 +1,17 @@
-import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from '../model/types';
-import { RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from './types';
-export type FindRepositoryParams<Model extends ModelBaseStructure> = {
-    filters?: RepositoryFindFielters<Model>;
-    fields?: NonFunctionPropertyNames<Model>[];
-    limits?: RepositoryLimitOptions<Model>;
-    orderBy?: RepositoryOrderBy<Model>;
-    options?: {
-        enableCount?: boolean;
-        minimal?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
-        maximum?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
-        distinct?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
-    };
-};
-export interface FindRepository<Model extends ModelBaseStructure, Params = FindRepositoryParams<Model>> {
-    find(options?: Params): Promise<RepositoryFindResult<Model>>;
-}
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from '../model/types';
+import { RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from './types';
+export type FindRepositoryParams<Model extends ModelBaseStructure> = {
+    filters?: RepositoryFindFielters<Model>;
+    fields?: NonFunctionPropertyNames<Model>[];
+    limits?: RepositoryLimitOptions<Model>;
+    orderBy?: RepositoryOrderBy<Model>;
+    options?: {
+        enableCount?: boolean;
+        minimal?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
+        maximum?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
+        distinct?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
+    };
+};
+export interface FindRepository<Model extends ModelBaseStructure, Params = FindRepositoryParams<Model>> {
+    find(options?: Params): Promise<RepositoryFindResult<Model>>;
+}

package/src/domain/generic/repository/get.repository.d.ts

@@ -1,5 +1,5 @@
-import { IdentifiersModel, ModelBaseStructure } from '../model/types';
-export type GetRepositoryParams<Model extends ModelBaseStructure> = IdentifiersModel<Model>;
-export interface GetRepository<Model extends ModelBaseStructure, Params = GetRepositoryParams<Model>> {
-    get(identifiers: Params): Promise<Model>;
-}
+import { IdentifiersModel, ModelBaseStructure } from '../model/types';
+export type GetRepositoryParams<Model extends ModelBaseStructure> = IdentifiersModel<Model>;
+export interface GetRepository<Model extends ModelBaseStructure, Params = GetRepositoryParams<Model>> {
+    get(identifiers: Params): Promise<Model>;
+}

package/src/domain/generic/repository/index.d.ts

@@ -1,9 +1,9 @@
-export * from './enums';
-export * from './types';
-export * from './create.repository';
-export * from './get.repository';
-export * from './delete.repository';
-export * from './update.repository';
-export * from './find.repository';
-export * from './read.repository';
-export * from './crud.repository';
+export * from './enums';
+export * from './types';
+export * from './create.repository';
+export * from './get.repository';
+export * from './delete.repository';
+export * from './update.repository';
+export * from './find.repository';
+export * from './read.repository';
+export * from './crud.repository';

package/src/domain/generic/repository/read.repository.d.ts

@@ -1,14 +1,14 @@
-import { ModelBaseStructure } from '../model/types';
-import { FindRepository, FindRepositoryParams } from './find.repository';
-import { GetRepository, GetRepositoryParams } from './get.repository';
-type ReadGenericRepository = {
-    Find?: any;
-    Get?: any;
-};
-export type ReadRepositoryParams<Model extends ModelBaseStructure> = {
-    Find?: FindRepositoryParams<Model>;
-    Get?: GetRepositoryParams<Model>;
-};
-export interface ReadRepository<Model extends ModelBaseStructure, Params extends ReadGenericRepository = ReadRepositoryParams<Model>> extends FindRepository<Model, FindRepositoryParams<Model> & Params['Find']>, GetRepository<Model, GetRepositoryParams<Model> & Params['Get']> {
-}
-export {};
+import { ModelBaseStructure } from '../model/types';
+import { FindRepository, FindRepositoryParams } from './find.repository';
+import { GetRepository, GetRepositoryParams } from './get.repository';
+type ReadGenericRepository = {
+    Find?: any;
+    Get?: any;
+};
+export type ReadRepositoryParams<Model extends ModelBaseStructure> = {
+    Find?: FindRepositoryParams<Model>;
+    Get?: GetRepositoryParams<Model>;
+};
+export interface ReadRepository<Model extends ModelBaseStructure, Params extends ReadGenericRepository = ReadRepositoryParams<Model>> extends FindRepository<Model, FindRepositoryParams<Model> & Params['Find']>, GetRepository<Model, GetRepositoryParams<Model> & Params['Get']> {
+}
+export {};

package/src/domain/generic/repository/types/index.d.ts

@@ -1,6 +1,6 @@
-export * from './repository-find-filters.type';
-export * from './repository-order-by-list.type';
-export * from './repository-limit-options.type';
-export * from './repository-find-result.type';
-export * from './repository-update-params.type';
-export * from './where-options.type';
+export * from './repository-find-filters.type';
+export * from './repository-order-by-list.type';
+export * from './repository-limit-options.type';
+export * from './repository-find-result.type';
+export * from './repository-update-params.type';
+export * from './where-options.type';

package/src/domain/generic/repository/types/repository-find-filters.type.d.ts

@@ -1,15 +1,15 @@
-import { PropType } from '../../../../utils';
-import { ModelBaseStructure } from '../../model';
-import { NonFunctionAndIdentifierPropertyNames } from '../../model/types/non-function-property-name.type';
-import { Where } from '../enums/where.enum';
-export type RepositoryFindFieltersOptions<Model, FieldName extends keyof Model> = {
-    operator: Where;
-    value?: PropType<Model, FieldName> | PropType<Model, FieldName>[];
-    ignoreCase?: boolean;
-    ignoreAccent?: boolean;
-};
-export type RepositoryFindField<Model, FieldName extends keyof Model> = RepositoryFindFieltersOptions<Model, FieldName> | RepositoryFindFieltersOptions<Model, FieldName>[] | Partial<PropType<Model, FieldName>>;
-export type NestedRepositoryFindFieltersOptions<Model> = {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Model, key>> : PropType<Required<Model>, key> extends any[] ? PropType<Required<Model>, key>[number] extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : PropType<Required<Model>, key>[number] extends Record<string, any> ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : RepositoryFindField<Model, key> : PropType<Model, key> extends Record<string, any> ? NestedRepositoryFindFieltersOptions<Required<PropType<Model, key>>> : RepositoryFindField<Model, key>;
-};
-export type RepositoryFindFielters<Model extends ModelBaseStructure> = NestedRepositoryFindFieltersOptions<Model>;
+import { PropType } from '../../../../utils';
+import { ModelBaseStructure } from '../../model';
+import { NonFunctionAndIdentifierPropertyNames } from '../../model/types/non-function-property-name.type';
+import { Where } from '../enums/where.enum';
+export type RepositoryFindFieltersOptions<Model, FieldName extends keyof Model> = {
+    operator: Where;
+    value?: PropType<Model, FieldName> | PropType<Model, FieldName>[];
+    ignoreCase?: boolean;
+    ignoreAccent?: boolean;
+};
+export type RepositoryFindField<Model, FieldName extends keyof Model> = RepositoryFindFieltersOptions<Model, FieldName> | RepositoryFindFieltersOptions<Model, FieldName>[] | Partial<PropType<Model, FieldName>>;
+export type NestedRepositoryFindFieltersOptions<Model> = {
+    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Model, key>> : PropType<Required<Model>, key> extends any[] ? PropType<Required<Model>, key>[number] extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : PropType<Required<Model>, key>[number] extends Record<string, any> ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : RepositoryFindField<Model, key> : PropType<Model, key> extends Record<string, any> ? NestedRepositoryFindFieltersOptions<Required<PropType<Model, key>>> : RepositoryFindField<Model, key>;
+};
+export type RepositoryFindFielters<Model extends ModelBaseStructure> = NestedRepositoryFindFieltersOptions<Model>;

package/src/domain/generic/repository/types/repository-find-result.type.d.ts

@@ -1,14 +1,14 @@
-import { NonFunctionAndIdentifierPropertiesWithNoPartial, NonFunctionAndIdentifierPropertyNames } from '../../model';
-type SortableFields<Model, K extends NonFunctionAndIdentifierPropertiesWithNoPartial<Model> = NonFunctionAndIdentifierPropertiesWithNoPartial<Model>> = {
-    [key in keyof K]: K[key];
-};
-export type RepositoryFindResult<Model> = {
-    data: Model[];
-    count?: number;
-    minimal?: SortableFields<Model>;
-    maximum?: SortableFields<Model>;
-    distinct?: {
-        [key in NonFunctionAndIdentifierPropertyNames<Model>]: Model[key] extends string ? Model[key][] : Model[key] extends number ? Model[key][] : Model[key] extends boolean ? Model[key][] : Model[key] extends Date ? Model[key][] : never;
-    };
-};
-export {};
+import { NonFunctionAndIdentifierPropertiesWithNoPartial, NonFunctionAndIdentifierPropertyNames } from '../../model';
+type SortableFields<Model, K extends NonFunctionAndIdentifierPropertiesWithNoPartial<Model> = NonFunctionAndIdentifierPropertiesWithNoPartial<Model>> = {
+    [key in keyof K]: K[key];
+};
+export type RepositoryFindResult<Model> = {
+    data: Model[];
+    count?: number;
+    minimal?: SortableFields<Model>;
+    maximum?: SortableFields<Model>;
+    distinct?: {
+        [key in NonFunctionAndIdentifierPropertyNames<Model>]: Model[key] extends string ? Model[key][] : Model[key] extends number ? Model[key][] : Model[key] extends boolean ? Model[key][] : Model[key] extends Date ? Model[key][] : never;
+    };
+};
+export {};