@infrab4a/connect 1.0.0-beta.29 → 1.0.0-beta.3

package/lib/domain/shopping/repositories/subscription/checkout.repository.d.ts

@@ -0,0 +1,4 @@
+import { CheckoutSubscription } from '../../models/subscription/checkout';
+import { CrudRepository } from '../../../general/repository/crud.repository';
+export interface CheckoutSubscriptionRepository extends CrudRepository<CheckoutSubscription> {
+}

package/lib/domain/shopping/repositories/subscription/plan.repository.d.ts

@@ -0,0 +1,4 @@
+import { SubscriptionPlan } from '../../models/subscription/plan';
+import { CrudRepository } from '../../../general/repository/crud.repository';
+export interface SubscriptionPlanRepository extends CrudRepository<SubscriptionPlan> {
+}

package/lib/domain/users/errors/unauthorized.error.d.ts

@@ -0,0 +1,4 @@
+export declare class UnauthorizedError extends Error {
+    readonly message: any;
+    constructor(message: any);
+}

package/lib/domain/users/errors/user-already-registered.error.d.ts

@@ -0,0 +1,4 @@
+export declare class UserAlreadyRegisteredError extends Error {
+    readonly message: any;
+    constructor(message: any);
+}

package/lib/domain/users/errors/weak-password.error.d.ts

@@ -0,0 +1,4 @@
+export declare class WeakPasswordError extends Error {
+    readonly message: string;
+    constructor(message?: string);
+}

package/lib/domain/users/models/beauty-profile.d.ts

@@ -0,0 +1,12 @@
+import { BaseModel } from '../../general/model/base.model';
+import { IdentifierFields } from '../../general/model/identifier-fields';
+import { NonFunctionPropertyNames } from '../../general/model/types/non-function-property-name.type';
+import { BeardSizes, HairTypes } from './enums';
+export declare class BeautyProfile extends BaseModel<BeautyProfile> implements IdentifierFields<BeautyProfile> {
+    id: string;
+    userId: string;
+    beardSize?: BeardSizes;
+    hairType?: HairTypes;
+    toPlain(): any;
+    identifierFields(): NonFunctionPropertyNames<BeautyProfile>[];
+}

package/lib/domain/users/models/lead.d.ts

@@ -0,0 +1,9 @@
+import { BaseModel } from '../../general/model/base.model';
+import { IdentifierFields } from '../../general/model/identifier-fields';
+import { NonFunctionPropertyNames } from '../../general/model/types';
+export declare class Lead extends BaseModel<Lead> implements IdentifierFields<Lead> {
+    id: string;
+    acceptsNewsletter: boolean;
+    email: string;
+    identifierFields(): NonFunctionPropertyNames<Lead>[];
+}

package/lib/domain/users/models/subscription/edition.d.ts

@@ -0,0 +1,15 @@
+import { BaseModel } from '../../../general/model/base.model';
+import { IdentifierFields } from '../../../general/model/identifier-fields';
+import { NonFunctionPropertyNames } from '../../../general/model/types/non-function-property-name.type';
+import { EditionStatus, BillingStatus } from './enums';
+export declare class Edition extends BaseModel<Edition> implements IdentifierFields<Edition> {
+    id: string;
+    subscriptionId: string;
+    billingStatus: BillingStatus;
+    editionId: number;
+    editionStatus: EditionStatus;
+    installment: number;
+    paymentId: string;
+    draftId?: string;
+    identifierFields(): NonFunctionPropertyNames<Edition>[];
+}

package/lib/domain/users/models/subscription/payment.d.ts

@@ -0,0 +1,14 @@
+import { BaseModel } from '../../../general/model/base.model';
+import { IdentifierFields } from '../../../general/model/identifier-fields';
+import { NonFunctionPropertyNames } from '../../../general/model/types';
+import { Payment } from '../../../shopping/models/payment';
+import { PaymentType } from './enums/payment-type.enum';
+export declare class SubscriptionPayment extends BaseModel<SubscriptionPayment> implements IdentifierFields<SubscriptionPayment> {
+    id: string;
+    subscriptionId: string;
+    paymentType: PaymentType;
+    createdAt: Date;
+    attempts?: number;
+    payment: Payment;
+    identifierFields(): NonFunctionPropertyNames<SubscriptionPayment>[];
+}

package/lib/domain/users/models/subscription/subscription.d.ts

@@ -0,0 +1,30 @@
+import { Address } from '../../../location/models/address';
+import { BaseModel } from '../../../general/model/base.model';
+import { Coupon } from '../../../shopping/models/coupons/coupon';
+import { IdentifierFields } from '../../../general/model/identifier-fields';
+import { NonFunctionPropertyNames } from '../../../general/model/types/non-function-property-name.type';
+import { SubscriptionPlan } from '../../../shopping/models/subscription/plan';
+import { User } from '../user';
+import { Edition } from './edition';
+import { Status } from './enums/status.enum';
+import { SubscriptionPayment } from './payment';
+export declare class Subscription extends BaseModel<Subscription> implements IdentifierFields<Subscription> {
+    id: string;
+    nextPayment: Date;
+    recurrence: boolean;
+    status: Status;
+    cardToken: string;
+    subtotalPrice?: number;
+    discount?: number;
+    totalPrice?: number;
+    createdAt: Date;
+    updatedAt: Date;
+    user: User;
+    subscriptionPlan: SubscriptionPlan;
+    shippingAddress: Address;
+    billingAddress?: Address;
+    coupon?: Coupon;
+    editions: Edition[];
+    payment?: SubscriptionPayment[];
+    identifierFields(): NonFunctionPropertyNames<Subscription>[];
+}

package/lib/domain/users/models/user-address.d.ts

@@ -0,0 +1,7 @@
+import { Address } from '../../location/models/address';
+import { NonFunctionPropertyNames } from '../../general/model/types/non-function-property-name.type';
+export declare class UserAddress extends Address {
+    id: string;
+    userId: string;
+    identifierFields(): NonFunctionPropertyNames<UserAddress>[];
+}

package/lib/domain/users/models/user-payment-method.d.ts

@@ -0,0 +1,13 @@
+import { BaseModel } from '../../general/model/base.model';
+import { NonFunctionPropertyNames } from '../../general/model/types/non-function-property-name.type';
+export declare class UserPaymentMethod extends BaseModel<UserPaymentMethod> {
+    brand: string;
+    cpf: string;
+    holderName: string;
+    last4: string;
+    pagarmeToken: string;
+    validUntil: string;
+    userId: string;
+    id: string;
+    identifierFields(): NonFunctionPropertyNames<UserPaymentMethod>[];
+}

package/lib/domain/users/models/user.d.ts

@@ -0,0 +1,24 @@
+import { BaseModel } from '../../general/model/base.model';
+import { IdentifierFields } from '../../general/model/identifier-fields';
+import { NonFunctionProperties, NonFunctionPropertyNames } from '../../general/model/types';
+import { Area, OfficePosition, UserType } from './enums';
+import { BeautyProfile } from './beauty-profile';
+export declare class User extends BaseModel<User> implements IdentifierFields<User> {
+    id: string;
+    cpf?: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    displayName?: string;
+    phone: string;
+    birthday?: Date;
+    acceptsNewsletter: boolean;
+    type?: UserType;
+    area?: Area;
+    officePosition?: OfficePosition;
+    isSubscriber?: boolean;
+    beautyProfile?: BeautyProfile;
+    static toInstance<T>(this: new () => Partial<T>, data: NonFunctionProperties<T> & NonFunctionProperties<User>): T;
+    identifierFields(): NonFunctionPropertyNames<User>[];
+    toPlain(): any;
+}

package/lib/domain/users/repositories/beauty-profile.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { BeautyProfile } from '../models/beauty-profile';
+export interface BeautyProfileRepository extends CrudRepository<BeautyProfile> {
+}

package/lib/domain/users/repositories/edition.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { Edition } from '../models/subscription/edition';
+export interface EditionRepository extends CrudRepository<Edition> {
+}

package/lib/domain/users/repositories/lead.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { Lead } from '../models/lead';
+export interface LeadRepository extends CrudRepository<Lead> {
+}

package/lib/domain/users/repositories/subscription-payment.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { SubscriptionPayment } from '../models/subscription/payment';
+export interface SubscriptionPaymentRepository extends CrudRepository<SubscriptionPayment> {
+}

package/lib/domain/users/repositories/subscription.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { Subscription } from '../models/subscription/subscription';
+export interface SubscriptionRepository extends CrudRepository<Subscription> {
+}

package/lib/domain/users/repositories/user-address.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { UserAddress } from '../models/user-address';
+export interface UserAddressRepository extends CrudRepository<UserAddress> {
+}

package/lib/domain/users/repositories/user-payment-method.repository.d.ts

@@ -0,0 +1,4 @@
+import { UserPaymentMethod } from '../models/user-payment-method';
+import { CrudRepository } from '../../general/repository/crud.repository';
+export interface UserPaymentMethodRepository extends CrudRepository<UserPaymentMethod> {
+}

package/lib/domain/users/repositories/user.repository.d.ts

@@ -0,0 +1,6 @@
+import { CrudRepository } from '../../general/repository/crud.repository';
+import { NonFunctionPropertyNames } from '../../general';
+import { User } from '../models/user';
+export interface UserRepository extends CrudRepository<User> {
+    checkIfExistsByField(field: Extract<NonFunctionPropertyNames<User>, 'cpf' | 'email'>, value: string): Promise<boolean>;
+}

package/lib/domain/users/services/authentication.service.d.ts

@@ -0,0 +1,11 @@
+import { BasicUserData } from './types/basic-user-data.type';
+export declare type LoginAndPasswordParams = {
+    email: string;
+    password: string;
+};
+export interface AuthenticationService {
+    signInWithEmailAndPassword(data: LoginAndPasswordParams): Promise<BasicUserData>;
+    signInWithGoogle(): Promise<BasicUserData>;
+    signOut(): Promise<void>;
+    signInAnonymously(): Promise<Pick<BasicUserData, 'id' | 'isAnonymous'>>;
+}

package/lib/domain/users/use-cases/index.d.ts

@@ -0,0 +1,3 @@
+export * from './authentication';
+export * from './register';
+export * from './signout';

package/lib/errors/duplicated-results.error.d.ts

@@ -0,0 +1,4 @@
+export declare class DuplicatedResultsError extends Error {
+    readonly message: any;
+    constructor(message: any);
+}

package/lib/errors/invalid-argument.error.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidArgumentError extends Error {
+    readonly message: any;
+    constructor(message: any);
+}

package/lib/errors/not-found.error.d.ts

@@ -0,0 +1,4 @@
+export declare class NotFoundError extends Error {
+    readonly message: any;
+    constructor(message: any);
+}

package/lib/errors/required-argument.error.d.ts

@@ -0,0 +1,5 @@
+export declare class RequiredArgumentError extends Error {
+    readonly args: string[];
+    arguments: string[];
+    constructor(args: string[]);
+}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './domain';
+export * from './errors';
+export * from './infra';
+export * from './utils';

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

@@ -0,0 +1,11 @@
+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 {
+    private readonly firebaseAuth;
+    constructor(firebaseAuth: firebase.auth.Auth);
+    signInWithEmailAndPassword(data: LoginAndPasswordParams): Promise<BasicUserData>;
+    signInWithGoogle(): Promise<BasicUserData>;
+    signOut(): Promise<void>;
+    signInAnonymously(): Promise<FirebaseUserWithId>;
+}

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

@@ -0,0 +1,8 @@
+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 {
+    private readonly firebaseAuth;
+    constructor(firebaseAuth: firebase.auth.Auth);
+    register(params: RegisterParams): Promise<FirebaseUserWithId>;
+}

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

@@ -0,0 +1,17 @@
+import { DocumentReference } from '@firebase/firestore-types';
+import { BaseModelWithIdentifier } from '../../../../domain';
+import { FirestoreHelpers, FirestoreRepository } from '../types';
+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/lib/infra/firebase/firestore/mixins/with-crud-firestore.mixin.d.ts

@@ -0,0 +1,29 @@
+import { BaseModelWithIdentifier } from '../../../../domain';
+import { FirestoreHelpers, FirestoreRepository } from '../types';
+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/lib/infra/firebase/firestore/mixins/with-delete-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 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/lib/infra/firebase/firestore/mixins/with-find-firestore.mixin.d.ts

@@ -0,0 +1,20 @@
+import { CollectionReference, Query } from '@firebase/firestore-types';
+import { BaseModelWithIdentifier, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderByList } from '../../../../domain';
+import { FirestoreHelpers, FirestoreRepository } from '../types';
+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/lib/infra/firebase/firestore/mixins/with-firestore.mixin.d.ts

@@ -0,0 +1,15 @@
+import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { BaseModelBuilder, BaseModelWithIdentifier } from '../../../../domain';
+import { MixinCtor } from '../../../../utils';
+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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/infra/firebase/firestore/repositories/catalog/category-firestore.repository.d.ts

@@ -0,0 +1,55 @@
+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): Promise<Product[]>;
+}
+export {};

package/lib/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 {};