@infrab4a/connect 0.17.1-beta.1 → 0.17.1-beta.2

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

@@ -0,0 +1,15 @@
+import { BaseModelWithIdentifier, NonFunctionProperties } from '../../../../domain';
+import { FirestoreHelpers, FirestoreRepository } from '../types';
+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

@@ -0,0 +1,10 @@
+import { QuerySnapshot, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { BaseModelWithIdentifier } from '../../../../domain';
+import { FirestoreRepository, FirestoreSubRepository } from '../types';
+import { MixinCtor } from '../../../../utils';
+export declare const withHelpers: <Model extends BaseModelWithIdentifier<Model>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<{}> & TMixinBase) => {
+    new (...args: any[]): {
+        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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,16 @@
+import { BaseModelWithIdentifier, RepositoryUpdateParams } from '../../../../domain';
+import { FirestoreHelpers, FirestoreRepository } from '../types';
+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

@@ -0,0 +1,9 @@
+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;
+    identifierFields(): NonFunctionPropertyNames<UserSearch>[];
+}

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

@@ -0,0 +1,58 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Category, CategoryRepository, Product, Shops } from '../../../../../domain';
+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);
+    getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
+    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
+        category: Category;
+        products: Product[];
+    }[]>;
+    mountCategory(category: Category, options?: {
+        limit?: number;
+        hasStock?: boolean;
+    }): Promise<Product[]>;
+}
+export {};

package/infra/firebase/firestore/repositories/catalog/index.d.ts

@@ -0,0 +1,4 @@
+export * from './category-firestore.repository';
+export * from './product-firestore.repository';
+export * from './product-variant-firestore.repository';
+export * from './subscription-product-firestore.repository';

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

@@ -0,0 +1,50 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+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;
+    constructor(firestore: FirebaseFirestore);
+    getBySlug(slug: string, shop: Shops): Promise<Product>;
+}
+export {};

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

@@ -0,0 +1,60 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Product, Variant, VariantRepository } from '../../../../../domain';
+import { ProductFirestoreRepository } from './product-firestore.repository';
+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;
+    constructor(firestore: FirebaseFirestore, parentRepository: ProductFirestoreRepository);
+}
+export {};

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

@@ -0,0 +1,49 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Product, SubscriptionProductRepository } from '../../../../../domain';
+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);
+}
+export {};

package/infra/firebase/firestore/repositories/index.d.ts

@@ -0,0 +1,4 @@
+export * from './users';
+export * from './catalog';
+export * from './shopping';
+export * from './shop-settings';

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

@@ -0,0 +1,57 @@
+import { DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { Home, HomeRepository } from '../../../../../domain';
+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);
+    buildModelInstance(): {
+        toFirestore: (data: Home) => DocumentData;
+        fromFirestore: (snap: QueryDocumentSnapshot<Home>) => Home;
+    };
+    private homeToFirestore;
+    private homeCategoryGroupToPlain;
+    private homeFromFirestore;
+    private plainToHomeCategoryGroup;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from './home-firestore.repository';
+export * from './shop-menu-firestore.repository';
+export * from './shop-settings-firestore.repository';

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

@@ -0,0 +1,49 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+import { ShopMenu, ShopMenuRepository } from '../../../../../domain';
+declare const ShopMenuFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<ShopMenu>): Promise<ShopMenu>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<ShopMenu>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<ShopMenu>): Partial<ShopMenu>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<ShopMenu>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<ShopMenu>;
+        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<ShopMenu>): Promise<ShopMenu>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<ShopMenu>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<ShopMenu>[], limits?: import("../../../../../domain").RepositoryLimitOptions<ShopMenu>, orderBy?: import("../../../../../domain").RepositoryOrderByList<ShopMenu>): Promise<import("../../../../../domain").RepositoryFindResult<ShopMenu>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<ShopMenu>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<ShopMenu> | import("@firebase/firestore-types").Query<ShopMenu>, filter: import("../../../../../domain").RepositoryFindFielters<ShopMenu>) => import("@firebase/firestore-types").Query<ShopMenu>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<ShopMenu> | import("@firebase/firestore-types").Query<ShopMenu>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<ShopMenu, import("../../../../../domain").NonFunctionPropertyNames<ShopMenu>>) => import("@firebase/firestore-types").Query<ShopMenu>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<ShopMenu> | import("@firebase/firestore-types").Query<ShopMenu>, filters: import("../../../../../domain").RepositoryFindFielters<ShopMenu>[], limits: import("../../../../../domain").RepositoryLimitOptions<ShopMenu>): Promise<import("@firebase/firestore-types").Query<ShopMenu>>;
+        calculateCount(data: ShopMenu[], limits: import("../../../../../domain").RepositoryLimitOptions<ShopMenu>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<ShopMenu>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<ShopMenu>): string;
+        create(data: Partial<ShopMenu>): Promise<ShopMenu>;
+        save(data: ShopMenu): Promise<import("@firebase/firestore-types").DocumentReference<ShopMenu>>;
+        buildCollectionPathForAdd(identifiers: Partial<ShopMenu>): 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<ShopMenu>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<ShopMenu>;
+        buildModelInstance(): {
+            toFirestore: (data: ShopMenu) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<ShopMenu>) => ShopMenu;
+        };
+    };
+};
+export declare class ShopMenuFirestoreRepository extends ShopMenuFirestoreRepository_base implements ShopMenuRepository {
+    readonly firestore: FirebaseFirestore;
+    constructor(firestore: FirebaseFirestore);
+}
+export {};

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

@@ -0,0 +1,49 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+import { ShopSettings, ShopSettingsRepository } from '../../../../../domain';
+declare const ShopSettingsFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<ShopSettings>): Promise<ShopSettings>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<ShopSettings>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<ShopSettings>): Partial<ShopSettings>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<ShopSettings>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<ShopSettings>;
+        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<ShopSettings>): Promise<ShopSettings>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<ShopSettings>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<ShopSettings>[], limits?: import("../../../../../domain").RepositoryLimitOptions<ShopSettings>, orderBy?: import("../../../../../domain").RepositoryOrderByList<ShopSettings>): Promise<import("../../../../../domain").RepositoryFindResult<ShopSettings>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<ShopSettings>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<ShopSettings> | import("@firebase/firestore-types").Query<ShopSettings>, filter: import("../../../../../domain").RepositoryFindFielters<ShopSettings>) => import("@firebase/firestore-types").Query<ShopSettings>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<ShopSettings> | import("@firebase/firestore-types").Query<ShopSettings>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<ShopSettings, import("../../../../../domain").NonFunctionPropertyNames<ShopSettings>>) => import("@firebase/firestore-types").Query<ShopSettings>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<ShopSettings> | import("@firebase/firestore-types").Query<ShopSettings>, filters: import("../../../../../domain").RepositoryFindFielters<ShopSettings>[], limits: import("../../../../../domain").RepositoryLimitOptions<ShopSettings>): Promise<import("@firebase/firestore-types").Query<ShopSettings>>;
+        calculateCount(data: ShopSettings[], limits: import("../../../../../domain").RepositoryLimitOptions<ShopSettings>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<ShopSettings>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<ShopSettings>): string;
+        create(data: Partial<ShopSettings>): Promise<ShopSettings>;
+        save(data: ShopSettings): Promise<import("@firebase/firestore-types").DocumentReference<ShopSettings>>;
+        buildCollectionPathForAdd(identifiers: Partial<ShopSettings>): 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<ShopSettings>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<ShopSettings>;
+        buildModelInstance(): {
+            toFirestore: (data: ShopSettings) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<ShopSettings>) => ShopSettings;
+        };
+    };
+};
+export declare class ShopSettingsFirestoreRepository extends ShopSettingsFirestoreRepository_base implements ShopSettingsRepository {
+    readonly firestore: FirebaseFirestore;
+    constructor(firestore: FirebaseFirestore);
+}
+export {};

package/infra/firebase/firestore/repositories/shopping/buy-2-win-firestore.repository.d.ts

@@ -0,0 +1,49 @@
+import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Buy2Win, Buy2WinRepository } from '../../../../../domain';
+declare const Buy2WinFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<Buy2Win>): Promise<Buy2Win>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Buy2Win>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Buy2Win>): Partial<Buy2Win>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<Buy2Win>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Buy2Win>;
+        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<Buy2Win>): Promise<Buy2Win>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Buy2Win>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Buy2Win>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Buy2Win>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Buy2Win>): Promise<import("../../../../../domain").RepositoryFindResult<Buy2Win>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Buy2Win>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Buy2Win> | import("@firebase/firestore-types").Query<Buy2Win>, filter: import("../../../../../domain").RepositoryFindFielters<Buy2Win>) => import("@firebase/firestore-types").Query<Buy2Win>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Buy2Win> | import("@firebase/firestore-types").Query<Buy2Win>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Buy2Win, import("../../../../../domain").NonFunctionPropertyNames<Buy2Win>>) => import("@firebase/firestore-types").Query<Buy2Win>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Buy2Win> | import("@firebase/firestore-types").Query<Buy2Win>, filters: import("../../../../../domain").RepositoryFindFielters<Buy2Win>[], limits: import("../../../../../domain").RepositoryLimitOptions<Buy2Win>): Promise<import("@firebase/firestore-types").Query<Buy2Win>>;
+        calculateCount(data: Buy2Win[], limits: import("../../../../../domain").RepositoryLimitOptions<Buy2Win>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<Buy2Win>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Buy2Win>): string;
+        create(data: Partial<Buy2Win>): Promise<Buy2Win>;
+        save(data: Buy2Win): Promise<import("@firebase/firestore-types").DocumentReference<Buy2Win>>;
+        buildCollectionPathForAdd(identifiers: Partial<Buy2Win>): 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<Buy2Win>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Buy2Win>;
+        buildModelInstance(): {
+            toFirestore: (data: Buy2Win) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Buy2Win>) => Buy2Win;
+        };
+    };
+};
+export declare class Buy2WinFirestoreRepository extends Buy2WinFirestoreRepository_base implements Buy2WinRepository {
+    readonly firestore: FirebaseFirestore;
+    constructor(firestore: FirebaseFirestore);
+}
+export {};