@infrab4a/connect 1.0.0-beta.38 → 1.0.0-beta.4

package/infra/elasticsearch/adapters/axios.adapter.d.ts

@@ -7,8 +7,5 @@ export declare type AxiosElasticSearchConfig = {
 export declare class AxiosAdapter<T extends BaseModel<T>> {
     private readonly config;
     constructor(config: AxiosElasticSearchConfig);
-    get(index: string): Promise<Partial<T>>;
     query(index: string, query: any): Promise<ElasticSearchResult<Partial<T>>>;
-    save(index: string, data: Partial<T>): Promise<void>;
-    delete(index: string): Promise<void>;
 }

package/infra/elasticsearch/adapters/elastic-search.adapter.d.ts

@@ -1,7 +1,4 @@
 import { ElasticSearchResult } from '../types/elastic-search-result';
 export interface ElasticSearchAdapter<T = any> {
-    get(index: string): Promise<T>;
     query(index: string, query: any): Promise<ElasticSearchResult<T>>;
-    save(index: string, data: Partial<T>): Promise<void>;
-    delete(index: string): Promise<void>;
 }

package/infra/elasticsearch/indexes/products-index.d.ts

@@ -1,15 +1,11 @@
-import { Product, Shops } from '../../../domain';
-import { ProductHasuraGraphQL } from '../../hasura-graphql';
 import { AxiosAdapter } from '../adapters';
+import { Product, Shops } from '../../../domain';
 export declare class ProductsIndex {
     private readonly adapter;
     constructor(adapter: AxiosAdapter<Product>);
-    get(id: any): Promise<Product>;
     findById(ids: string[], options?: {
         hasStock: boolean;
         size: number;
         shop: Shops;
     }): Promise<Product[]>;
-    save(product: ProductHasuraGraphQL): Promise<void>;
-    delete(product: ProductHasuraGraphQL): Promise<void>;
 }

package/infra/firebase/auth/authentication-firebase-auth.service.d.ts

@@ -1,4 +1,4 @@
-import firebase from 'firebase';
+import firebase from 'firebase/app';
 import { AuthenticationService, BasicUserData, LoginAndPasswordParams } from '../../../domain';
 import { FirebaseUserWithId } from './types/firebase-user-with-id.type';
 export declare class AuthenticationFirebaseAuthService implements AuthenticationService {

package/infra/firebase/auth/register-firebase-auth.service.d.ts

@@ -1,4 +1,4 @@
-import firebase from 'firebase';
+import firebase from 'firebase/app';
 import { RegisterParams, RegisterService } from '../../../domain';
 import { FirebaseUserWithId } from './types/firebase-user-with-id.type';
 export declare class RegisterFirebaseAuthService implements RegisterService {

package/infra/firebase/firestore/mixins/with-create-firestore.mixin.d.ts

@@ -1,4 +1,17 @@
-import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../../domain';
+import { DocumentReference } from '@firebase/firestore-types';
+import { BaseModelWithIdentifier } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
-export declare const withCreateFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & CreateRepository<TBase, CreateRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { MixinCtor } from '../../../../utils';
+export declare const withCreateFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
+    new (...args: any[]): {
+        create(data: Partial<TBase>): Promise<TBase>;
+        save(data: TBase): Promise<DocumentReference<TBase>>;
+        buildCollectionPathForAdd(identifiers: Partial<TBase>): string;
+        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/mixins/with-crud-firestore.mixin.d.ts

@@ -1,4 +1,29 @@
-import { ModelBaseStructure, CrudRepository } from '../../../../domain';
+import { BaseModelWithIdentifier } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
-export declare const withCrudFirestore: <TBase extends ModelBaseStructure<any, any>, Repository = CrudRepository<TBase, import("../../../../domain").CrudParams<TBase>>, TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & Repository & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { MixinCtor } from '../../../../utils';
+export declare const withCrudFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
+    new (...args: any[]): {
+        update(data: import("../../../../domain").RepositoryUpdateParams<TBase>): Promise<TBase>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../domain").RepositoryUpdateParams<TBase>): string;
+        paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<TBase>): Partial<TBase>;
+        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
+        get(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): Promise<TBase>;
+        buildCollectionPathForGet(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): string;
+        find(filters?: import("../../../../domain").RepositoryFindFielters<TBase>[], limits?: import("../../../../domain").RepositoryLimitOptions<TBase>, orderBy?: import("../../../../domain").RepositoryOrderByList<TBase>): Promise<import("../../../../domain").RepositoryFindResult<TBase>>;
+        buildCollectionPathForFind(filters: import("../../../../domain").RepositoryFindFielters<TBase>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<TBase> | import("@firebase/firestore-types").Query<TBase>, filter: import("../../../../domain").RepositoryFindFielters<TBase>) => import("@firebase/firestore-types").Query<TBase>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<TBase> | import("@firebase/firestore-types").Query<TBase>, fieldName: string | import("../../../../domain").NonFunctionPropertyNames<TBase>, options: import("../../../../domain").RepositoryFindFieltersOptions<TBase, import("../../../../domain").NonFunctionPropertyNames<TBase>>) => import("@firebase/firestore-types").Query<TBase>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<TBase> | import("@firebase/firestore-types").Query<TBase>, filters: import("../../../../domain").RepositoryFindFielters<TBase>[], limits: import("../../../../domain").RepositoryLimitOptions<TBase>): Promise<import("@firebase/firestore-types").Query<TBase>>;
+        calculateCount(data: TBase[], limits: import("../../../../domain").RepositoryLimitOptions<TBase>): number;
+        delete(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): string;
+        create(data: Partial<TBase>): Promise<TBase>;
+        save(data: TBase): Promise<import("@firebase/firestore-types").DocumentReference<TBase>>;
+        buildCollectionPathForAdd(identifiers: Partial<TBase>): string;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/mixins/with-delete-firestore.mixin.d.ts

@@ -1,4 +1,15 @@
-import { ModelBaseStructure, DeleteRepository, DeleteRepositoryParams } from '../../../../domain';
+import { BaseModelWithIdentifier, NonFunctionProperties } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
-export declare const withDeleteFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & DeleteRepository<TBase, DeleteRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { MixinCtor } from '../../../../utils';
+export declare const withDeleteFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
+    new (...args: any[]): {
+        delete(identifiers: NonFunctionProperties<TBase>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: NonFunctionProperties<TBase>): string;
+        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/mixins/with-find-firestore.mixin.d.ts

@@ -1,4 +1,20 @@
-import { FindRepository, ModelBaseStructure } from '../../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { CollectionReference, Query } from '@firebase/firestore-types';
+import { BaseModelWithIdentifier, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderByList } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-export declare const withFindFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & FindRepository<TBase, import("../../../../domain").FindRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { MixinCtor } from '../../../../utils';
+export declare const withFindFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
+    new (...args: any[]): {
+        find(filters?: RepositoryFindFielters<TBase>[], limits?: RepositoryLimitOptions<TBase>, orderBy?: RepositoryOrderByList<TBase>): Promise<RepositoryFindResult<TBase>>;
+        buildCollectionPathForFind(filters: RepositoryFindFielters<TBase>[]): string;
+        makeFirestoreWhere: (queryReference: CollectionReference<TBase> | Query<TBase>, filter: RepositoryFindFielters<TBase>) => Query<TBase>;
+        buildWhereSentence: (queryReference: CollectionReference<TBase> | Query<TBase>, fieldName: string | NonFunctionPropertyNames<TBase>, options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>) => Query<TBase>;
+        defineLimits(query: CollectionReference<TBase> | Query<TBase>, filters: RepositoryFindFielters<TBase>[], limits: RepositoryLimitOptions<TBase>): Promise<Query<TBase>>;
+        calculateCount(data: TBase[], limits: RepositoryLimitOptions<TBase>): number;
+        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+        collection(path?: string): CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/mixins/with-firestore.mixin.d.ts

@@ -1,4 +1,15 @@
-import { ModelBaseStructure } from '../../../../domain';
+import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { BaseModelBuilder, BaseModelWithIdentifier } from '../../../../domain';
 import { MixinCtor } from '../../../../utils';
-import { FirestoreRepository } from '../types';
-export declare const withFirestore: <TBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<FirestoreRepository<TBase>, never>;
+export declare const withFirestore: <TBase extends BaseModelWithIdentifier<TBase>>(MixinBase: MixinCtor) => {
+    new (...args: Array<any>): {
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: BaseModelBuilder<TBase>;
+        collection(path?: string): CollectionReference<TBase>;
+        buildModelInstance(): {
+            toFirestore: (data: TBase) => DocumentData;
+            fromFirestore: (snap: QueryDocumentSnapshot<TBase>) => TBase;
+        };
+    };
+};

package/infra/firebase/firestore/mixins/with-get-firestore.mixin.d.ts

@@ -1,4 +1,15 @@
-import { ModelBaseStructure, GetRepository } from '../../../../domain';
+import { BaseModelWithIdentifier, NonFunctionProperties } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
-export declare const withGetFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & GetRepository<TBase, import("../../../../domain").GetRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { MixinCtor } from '../../../../utils';
+export declare const withGetFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
+    new (...args: any[]): {
+        get(identifiers: NonFunctionProperties<TBase>): Promise<TBase>;
+        buildCollectionPathForGet(identifiers: NonFunctionProperties<TBase>): string;
+        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/mixins/with-helpers.mixin.d.ts

@@ -1,11 +1,10 @@
 import { QuerySnapshot, QueryDocumentSnapshot } from '@firebase/firestore-types';
-import { ModelBaseStructure } from '../../../../domain';
+import { BaseModelWithIdentifier } from '../../../../domain';
 import { FirestoreRepository, FirestoreSubRepository } from '../types';
 import { MixinCtor } from '../../../../utils';
-export declare const withHelpers: <TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<any, any[]> & TMixinBase) => {
+export declare const withHelpers: <Model extends BaseModelWithIdentifier<Model>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<{}> & TMixinBase) => {
     new (...args: any[]): {
-        [x: string]: any;
-        toArray<T extends ModelBaseStructure<any, any>>(snapShot: QuerySnapshot<T> | QueryDocumentSnapshot<T>[]): T[];
-        isSubCollection<T_2 extends ModelBaseStructure<any, any>>(repository: FirestoreRepository<T_2>): repository is FirestoreSubRepository<T_2, import("../../../../domain").BaseModel<{}, "id">>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: QuerySnapshot<T> | QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_2 extends BaseModelWithIdentifier<T_2>>(repository: FirestoreRepository<T_2>): repository is FirestoreSubRepository<T_2, BaseModelWithIdentifier<{}>>;
     };
 } & TMixinBase;

package/infra/firebase/firestore/mixins/with-sub-collection.mixin.d.ts

@@ -1,7 +1,14 @@
-import { ModelBaseStructure } from '../../../../domain';
-import { FirestoreHelpers, FirestoreRepository, FirestoreSubRepository } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
-export declare const withSubCollection: <TBase extends ModelBaseStructure<any, any>, TBaseParent extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase>, any[]> & TMixinBase, ParentModel: new () => TBaseParent) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & {
-    readonly parentRepository: FirestoreRepository<TBaseParent>;
-    parentIdField: Extract<import("../../../../domain").NonFunctionAndIdentifierPropertyNames<TBase>, import("../../../../utils").ArrayElement<import("../../../../utils").PropType<TBase, "identifiersFields">>>;
-} & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { CollectionReference, FirebaseFirestore } from '@firebase/firestore-types';
+import { BaseModelWithIdentifier, NonFunctionPropertyNames } from '../../../../domain';
+import { FirestoreRepository } from '../types';
+import { MixinCtor } from '../../../../utils';
+export declare const withSubCollection: <TBase extends BaseModelWithIdentifier<TBase>, TBaseParent extends BaseModelWithIdentifier<TBaseParent>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase>> & TMixinBase, ParentModel: new () => TBaseParent) => {
+    new (...args: Array<any>): {
+        readonly parentRepository: FirestoreRepository<TBaseParent>;
+        parentIdField: NonFunctionPropertyNames<TBase>;
+        collection(path?: string): CollectionReference<TBase>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/mixins/with-update-firestore.mixin.d.ts

@@ -1,7 +1,16 @@
-import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } from '../../../../domain';
+import { BaseModelWithIdentifier, RepositoryUpdateParams } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
-export declare type UpdateFirestoreRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {
-    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
-};
-export declare const withUpdateFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & UpdateRepository<TBase, RepositoryUpdateParams<TBase>> & InstanceType<TMixinBase> & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;
+import { MixinCtor } from '../../../../utils';
+export declare const withUpdateFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
+    new (...args: any[]): {
+        update(data: RepositoryUpdateParams<TBase>): Promise<TBase>;
+        buildCollectionPathForUpdate(identifiers: RepositoryUpdateParams<TBase>): string;
+        paramsToPlain(params: RepositoryUpdateParams<TBase>): Partial<TBase>;
+        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../domain").BaseModelBuilder<TBase>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
+    };
+} & TMixinBase;

package/infra/firebase/firestore/models/user-search.d.ts

@@ -1,9 +1,9 @@
-import { BaseModel, GenericIdentifier } from '../../../../domain/generic';
-export declare class UserSearch extends BaseModel<UserSearch> {
+import { BaseModel, IdentifierFields, NonFunctionPropertyNames } from '../../../../domain/general';
+export declare class UserSearch extends BaseModel<UserSearch> implements IdentifierFields<UserSearch> {
     id: string;
     cpf?: string;
     email?: string;
     createdAt: Date;
     copiedAt: Date;
-    static get identifiersFields(): GenericIdentifier[];
+    identifierFields(): NonFunctionPropertyNames<UserSearch>[];
 }

package/infra/firebase/firestore/repositories/catalog/category-firestore.repository.d.ts

@@ -1,6 +1,47 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { Category, CategoryRepository, Product, Shops } from '../../../../../domain';
-declare const CategoryFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<Category> & import("../../../../../domain").CrudRepository<Category, import("../../../../../domain").CrudParams<Category>> & import("@infrab4a/connect").FirestoreHelpers, never>;
+declare const CategoryFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<Category>): Promise<Category>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Category>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Category>): Partial<Category>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Category>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Category>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+        get(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): Promise<Category>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Category>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Category>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Category>): Promise<import("../../../../../domain").RepositoryFindResult<Category>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Category>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Category> | import("@firebase/firestore-types").Query<Category>, filter: import("../../../../../domain").RepositoryFindFielters<Category>) => import("@firebase/firestore-types").Query<Category>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Category> | import("@firebase/firestore-types").Query<Category>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Category, import("../../../../../domain").NonFunctionPropertyNames<Category>>) => import("@firebase/firestore-types").Query<Category>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Category> | import("@firebase/firestore-types").Query<Category>, filters: import("../../../../../domain").RepositoryFindFielters<Category>[], limits: import("../../../../../domain").RepositoryLimitOptions<Category>): Promise<import("@firebase/firestore-types").Query<Category>>;
+        calculateCount(data: Category[], limits: import("../../../../../domain").RepositoryLimitOptions<Category>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): string;
+        create(data: Partial<Category>): Promise<Category>;
+        save(data: Category): Promise<import("@firebase/firestore-types").DocumentReference<Category>>;
+        buildCollectionPathForAdd(identifiers: Partial<Category>): string;
+    };
+} & {
+    new (...args: any[]): {
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+    };
+} & {
+    new (...args: any[]): {
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Category>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Category>;
+        buildModelInstance(): {
+            toFirestore: (data: Category) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Category>) => Category;
+        };
+    };
+};
 export declare class CategoryFirestoreRepository extends CategoryFirestoreRepository_base implements CategoryRepository {
     readonly firestore: FirebaseFirestore;
     constructor(firestore: FirebaseFirestore);

package/infra/firebase/firestore/repositories/catalog/product-firestore.repository.d.ts

@@ -1,11 +1,50 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
-import { Product, ProductRepository, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain';
-declare const ProductFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<Product> & import("../../../../../domain").CrudRepository<Product, import("../../../../../domain").CrudParams<Product>> & import("@infrab4a/connect").FirestoreHelpers, never>;
+import { Product, ProductRepository, Shops } from '../../../../../domain';
+declare const ProductFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<Product>): Promise<Product>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Product>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Product>): Partial<Product>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Product>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+        get(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<Product>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Product>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Product>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Product>): Promise<import("../../../../../domain").RepositoryFindResult<Product>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Product>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filter: import("../../../../../domain").RepositoryFindFielters<Product>) => import("@firebase/firestore-types").Query<Product>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Product, import("../../../../../domain").NonFunctionPropertyNames<Product>>) => import("@firebase/firestore-types").Query<Product>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filters: import("../../../../../domain").RepositoryFindFielters<Product>[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): Promise<import("@firebase/firestore-types").Query<Product>>;
+        calculateCount(data: Product[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
+        create(data: Partial<Product>): Promise<Product>;
+        save(data: Product): Promise<import("@firebase/firestore-types").DocumentReference<Product>>;
+        buildCollectionPathForAdd(identifiers: Partial<Product>): string;
+    };
+} & {
+    new (...args: any[]): {
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+    };
+} & {
+    new (...args: any[]): {
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Product>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
+        buildModelInstance(): {
+            toFirestore: (data: Product) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Product>) => Product;
+        };
+    };
+};
 export declare class ProductFirestoreRepository extends ProductFirestoreRepository_base implements ProductRepository {
     readonly firestore: FirebaseFirestore;
-    private reviews;
     constructor(firestore: FirebaseFirestore);
-    getBySlug(slug: string): Promise<Product>;
-    fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
+    getBySlug(slug: string, shop: Shops): Promise<Product>;
 }
 export {};

package/infra/firebase/firestore/repositories/catalog/product-variant-firestore.repository.d.ts

@@ -1,10 +1,57 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { Product, Variant, VariantRepository } from '../../../../../domain';
 import { ProductFirestoreRepository } from './product-firestore.repository';
-declare const ProductVariantFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<Variant> & import("../../../../../domain").CrudRepository<Variant, import("../../../../../domain").CrudParams<Variant>> & import("@infrab4a/connect").FirestoreHelpers & {
-    readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<Product>;
-    parentIdField: "id" | "productId";
-}, never>;
+declare const ProductVariantFirestoreRepository_base: {
+    new (...args: any[]): {
+        readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<Product>;
+        parentIdField: import("../../../../../domain").NonFunctionPropertyNames<Variant>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Variant>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Variant>;
+    };
+} & {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<Variant>): Promise<Variant>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Variant>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Variant>): Partial<Variant>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Variant>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Variant>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+        get(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): Promise<Variant>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Variant>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Variant>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Variant>): Promise<import("../../../../../domain").RepositoryFindResult<Variant>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Variant>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Variant> | import("@firebase/firestore-types").Query<Variant>, filter: import("../../../../../domain").RepositoryFindFielters<Variant>) => import("@firebase/firestore-types").Query<Variant>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Variant> | import("@firebase/firestore-types").Query<Variant>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Variant, import("../../../../../domain").NonFunctionPropertyNames<Variant>>) => import("@firebase/firestore-types").Query<Variant>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Variant> | import("@firebase/firestore-types").Query<Variant>, filters: import("../../../../../domain").RepositoryFindFielters<Variant>[], limits: import("../../../../../domain").RepositoryLimitOptions<Variant>): Promise<import("@firebase/firestore-types").Query<Variant>>;
+        calculateCount(data: Variant[], limits: import("../../../../../domain").RepositoryLimitOptions<Variant>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): string;
+        create(data: Partial<Variant>): Promise<Variant>;
+        save(data: Variant): Promise<import("@firebase/firestore-types").DocumentReference<Variant>>;
+        buildCollectionPathForAdd(identifiers: Partial<Variant>): string;
+    };
+} & {
+    new (...args: any[]): {
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+    };
+} & {
+    new (...args: any[]): {
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Variant>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Variant>;
+        buildModelInstance(): {
+            toFirestore: (data: Variant) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Variant>) => Variant;
+        };
+    };
+};
 export declare class ProductVariantFirestoreRepository extends ProductVariantFirestoreRepository_base implements VariantRepository {
     readonly firestore: FirebaseFirestore;
     readonly parentRepository: ProductFirestoreRepository;

package/infra/firebase/firestore/repositories/catalog/subscription-product-firestore.repository.d.ts

@@ -1,6 +1,47 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { Product, SubscriptionProductRepository } from '../../../../../domain';
-declare const SubscriptionProductFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<Product> & import("../../../../../domain").CrudRepository<Product, import("../../../../../domain").CrudParams<Product>> & import("@infrab4a/connect").FirestoreHelpers, never>;
+declare const SubscriptionProductFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<Product>): Promise<Product>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Product>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Product>): Partial<Product>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Product>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+        get(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<Product>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Product>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Product>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Product>): Promise<import("../../../../../domain").RepositoryFindResult<Product>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Product>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filter: import("../../../../../domain").RepositoryFindFielters<Product>) => import("@firebase/firestore-types").Query<Product>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Product, import("../../../../../domain").NonFunctionPropertyNames<Product>>) => import("@firebase/firestore-types").Query<Product>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filters: import("../../../../../domain").RepositoryFindFielters<Product>[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): Promise<import("@firebase/firestore-types").Query<Product>>;
+        calculateCount(data: Product[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
+        create(data: Partial<Product>): Promise<Product>;
+        save(data: Product): Promise<import("@firebase/firestore-types").DocumentReference<Product>>;
+        buildCollectionPathForAdd(identifiers: Partial<Product>): string;
+    };
+} & {
+    new (...args: any[]): {
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+    };
+} & {
+    new (...args: any[]): {
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Product>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
+        buildModelInstance(): {
+            toFirestore: (data: Product) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Product>) => Product;
+        };
+    };
+};
 export declare class SubscriptionProductFirestoreRepository extends SubscriptionProductFirestoreRepository_base implements SubscriptionProductRepository {
     readonly firestore: FirebaseFirestore;
     constructor(firestore: FirebaseFirestore);

package/infra/firebase/firestore/repositories/shop-settings/home-firestore.repository.d.ts

@@ -1,6 +1,47 @@
 import { DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
 import { Home, HomeRepository } from '../../../../../domain';
-declare const HomeFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<Home> & import("../../../../../domain").CrudRepository<Home, import("../../../../../domain").CrudParams<Home>> & import("@infrab4a/connect").FirestoreHelpers, never>;
+declare const HomeFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<Home>): Promise<Home>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Home>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Home>): Partial<Home>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Home>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Home>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+        get(identifiers: import("../../../../../domain").NonFunctionProperties<Home>): Promise<Home>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Home>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Home>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Home>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Home>): Promise<import("../../../../../domain").RepositoryFindResult<Home>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Home>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Home> | import("@firebase/firestore-types").Query<Home>, filter: import("../../../../../domain").RepositoryFindFielters<Home>) => import("@firebase/firestore-types").Query<Home>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Home> | import("@firebase/firestore-types").Query<Home>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Home, import("../../../../../domain").NonFunctionPropertyNames<Home>>) => import("@firebase/firestore-types").Query<Home>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Home> | import("@firebase/firestore-types").Query<Home>, filters: import("../../../../../domain").RepositoryFindFielters<Home>[], limits: import("../../../../../domain").RepositoryLimitOptions<Home>): Promise<import("@firebase/firestore-types").Query<Home>>;
+        calculateCount(data: Home[], limits: import("../../../../../domain").RepositoryLimitOptions<Home>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<Home>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Home>): string;
+        create(data: Partial<Home>): Promise<Home>;
+        save(data: Home): Promise<import("@firebase/firestore-types").DocumentReference<Home>>;
+        buildCollectionPathForAdd(identifiers: Partial<Home>): string;
+    };
+} & {
+    new (...args: any[]): {
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | QueryDocumentSnapshot<T_2>[]): T_2[];
+        isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
+    };
+} & {
+    new (...args: any[]): {
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Home>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Home>;
+        buildModelInstance(): {
+            toFirestore: (data: Home) => DocumentData;
+            fromFirestore: (snap: QueryDocumentSnapshot<Home>) => Home;
+        };
+    };
+};
 export declare class HomeFirestoreRepository extends HomeFirestoreRepository_base implements HomeRepository {
     readonly firestore: FirebaseFirestore;
     constructor(firestore: FirebaseFirestore);