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

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

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

package/infra/firebase/firestore/repositories/users/subscription-payment-firestore.repository.d.ts

@@ -1,10 +1,57 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { SubscriptionPayment, Subscription, SubscriptionPaymentRepository } from '../../../../../domain';
 import { SubscriptionFirestoreRepository } from './subscription-firestore.repository';
-declare const SubscriptionPaymentFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<SubscriptionPayment> & import("../../../../../domain").CrudRepository<SubscriptionPayment, import("../../../../../domain").CrudParams<SubscriptionPayment>> & import("@infrab4a/connect").FirestoreHelpers & {
-    readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<Subscription>;
-    parentIdField: "id" | "subscriptionId";
-}, never>;
+declare const SubscriptionPaymentFirestoreRepository_base: {
+    new (...args: any[]): {
+        readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<Subscription>;
+        parentIdField: import("../../../../../domain").NonFunctionPropertyNames<SubscriptionPayment>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<SubscriptionPayment>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<SubscriptionPayment>;
+    };
+} & {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<SubscriptionPayment>): Promise<SubscriptionPayment>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<SubscriptionPayment>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<SubscriptionPayment>): Partial<SubscriptionPayment>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<SubscriptionPayment>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<SubscriptionPayment>;
+        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<SubscriptionPayment>): Promise<SubscriptionPayment>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<SubscriptionPayment>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<SubscriptionPayment>[], limits?: import("../../../../../domain").RepositoryLimitOptions<SubscriptionPayment>, orderBy?: import("../../../../../domain").RepositoryOrderByList<SubscriptionPayment>): Promise<import("../../../../../domain").RepositoryFindResult<SubscriptionPayment>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<SubscriptionPayment>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<SubscriptionPayment> | import("@firebase/firestore-types").Query<SubscriptionPayment>, filter: import("../../../../../domain").RepositoryFindFielters<SubscriptionPayment>) => import("@firebase/firestore-types").Query<SubscriptionPayment>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<SubscriptionPayment> | import("@firebase/firestore-types").Query<SubscriptionPayment>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<SubscriptionPayment, import("../../../../../domain").NonFunctionPropertyNames<SubscriptionPayment>>) => import("@firebase/firestore-types").Query<SubscriptionPayment>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<SubscriptionPayment> | import("@firebase/firestore-types").Query<SubscriptionPayment>, filters: import("../../../../../domain").RepositoryFindFielters<SubscriptionPayment>[], limits: import("../../../../../domain").RepositoryLimitOptions<SubscriptionPayment>): Promise<import("@firebase/firestore-types").Query<SubscriptionPayment>>;
+        calculateCount(data: SubscriptionPayment[], limits: import("../../../../../domain").RepositoryLimitOptions<SubscriptionPayment>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<SubscriptionPayment>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<SubscriptionPayment>): string;
+        create(data: Partial<SubscriptionPayment>): Promise<SubscriptionPayment>;
+        save(data: SubscriptionPayment): Promise<import("@firebase/firestore-types").DocumentReference<SubscriptionPayment>>;
+        buildCollectionPathForAdd(identifiers: Partial<SubscriptionPayment>): 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<SubscriptionPayment>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<SubscriptionPayment>;
+        buildModelInstance(): {
+            toFirestore: (data: SubscriptionPayment) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<SubscriptionPayment>) => SubscriptionPayment;
+        };
+    };
+};
 export declare class SubscriptionPaymentFirestoreRepository extends SubscriptionPaymentFirestoreRepository_base implements SubscriptionPaymentRepository {
     readonly firestore: FirebaseFirestore;
     readonly parentRepository: SubscriptionFirestoreRepository;

package/infra/firebase/firestore/repositories/users/user-address-firestore.repository.d.ts

@@ -1,10 +1,57 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { User, UserAddress, UserAddressRepository } from '../../../../../domain';
 import { UserFirestoreRepository } from './user-firestore.repository';
-declare const UserAddressFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<UserAddress> & import("../../../../../domain").CrudRepository<UserAddress, import("../../../../../domain").CrudParams<UserAddress>> & import("@infrab4a/connect").FirestoreHelpers & {
-    readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
-    parentIdField: "id" | "userId";
-}, never>;
+declare const UserAddressFirestoreRepository_base: {
+    new (...args: any[]): {
+        readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
+        parentIdField: import("../../../../../domain").NonFunctionPropertyNames<UserAddress>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<UserAddress>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<UserAddress>;
+    };
+} & {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<UserAddress>): Promise<UserAddress>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<UserAddress>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<UserAddress>): Partial<UserAddress>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<UserAddress>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<UserAddress>;
+        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<UserAddress>): Promise<UserAddress>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<UserAddress>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<UserAddress>[], limits?: import("../../../../../domain").RepositoryLimitOptions<UserAddress>, orderBy?: import("../../../../../domain").RepositoryOrderByList<UserAddress>): Promise<import("../../../../../domain").RepositoryFindResult<UserAddress>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<UserAddress>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<UserAddress> | import("@firebase/firestore-types").Query<UserAddress>, filter: import("../../../../../domain").RepositoryFindFielters<UserAddress>) => import("@firebase/firestore-types").Query<UserAddress>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<UserAddress> | import("@firebase/firestore-types").Query<UserAddress>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<UserAddress, import("../../../../../domain").NonFunctionPropertyNames<UserAddress>>) => import("@firebase/firestore-types").Query<UserAddress>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<UserAddress> | import("@firebase/firestore-types").Query<UserAddress>, filters: import("../../../../../domain").RepositoryFindFielters<UserAddress>[], limits: import("../../../../../domain").RepositoryLimitOptions<UserAddress>): Promise<import("@firebase/firestore-types").Query<UserAddress>>;
+        calculateCount(data: UserAddress[], limits: import("../../../../../domain").RepositoryLimitOptions<UserAddress>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<UserAddress>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<UserAddress>): string;
+        create(data: Partial<UserAddress>): Promise<UserAddress>;
+        save(data: UserAddress): Promise<import("@firebase/firestore-types").DocumentReference<UserAddress>>;
+        buildCollectionPathForAdd(identifiers: Partial<UserAddress>): 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<UserAddress>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<UserAddress>;
+        buildModelInstance(): {
+            toFirestore: (data: UserAddress) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<UserAddress>) => UserAddress;
+        };
+    };
+};
 export declare class UserAddressFirestoreRepository extends UserAddressFirestoreRepository_base implements UserAddressRepository {
     readonly firestore: FirebaseFirestore;
     readonly parentRepository: UserFirestoreRepository;

package/infra/firebase/firestore/repositories/users/user-beauty-profile-firestore.repository.d.ts

@@ -1,10 +1,57 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { BeautyProfile, BeautyProfileRepository, User } from '../../../../../domain';
 import { UserFirestoreRepository } from './user-firestore.repository';
-declare const UserBeautyProfileFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<BeautyProfile> & import("../../../../../domain").CrudRepository<BeautyProfile, import("../../../../../domain").CrudParams<BeautyProfile>> & import("@infrab4a/connect").FirestoreHelpers & {
-    readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
-    parentIdField: "id" | "userId";
-}, never>;
+declare const UserBeautyProfileFirestoreRepository_base: {
+    new (...args: any[]): {
+        readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
+        parentIdField: import("../../../../../domain").NonFunctionPropertyNames<BeautyProfile>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<BeautyProfile>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<BeautyProfile>;
+    };
+} & {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<BeautyProfile>): Promise<BeautyProfile>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<BeautyProfile>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<BeautyProfile>): Partial<BeautyProfile>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<BeautyProfile>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<BeautyProfile>;
+        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<BeautyProfile>): Promise<BeautyProfile>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<BeautyProfile>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<BeautyProfile>[], limits?: import("../../../../../domain").RepositoryLimitOptions<BeautyProfile>, orderBy?: import("../../../../../domain").RepositoryOrderByList<BeautyProfile>): Promise<import("../../../../../domain").RepositoryFindResult<BeautyProfile>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<BeautyProfile>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<BeautyProfile> | import("@firebase/firestore-types").Query<BeautyProfile>, filter: import("../../../../../domain").RepositoryFindFielters<BeautyProfile>) => import("@firebase/firestore-types").Query<BeautyProfile>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<BeautyProfile> | import("@firebase/firestore-types").Query<BeautyProfile>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<BeautyProfile, import("../../../../../domain").NonFunctionPropertyNames<BeautyProfile>>) => import("@firebase/firestore-types").Query<BeautyProfile>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<BeautyProfile> | import("@firebase/firestore-types").Query<BeautyProfile>, filters: import("../../../../../domain").RepositoryFindFielters<BeautyProfile>[], limits: import("../../../../../domain").RepositoryLimitOptions<BeautyProfile>): Promise<import("@firebase/firestore-types").Query<BeautyProfile>>;
+        calculateCount(data: BeautyProfile[], limits: import("../../../../../domain").RepositoryLimitOptions<BeautyProfile>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<BeautyProfile>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<BeautyProfile>): string;
+        create(data: Partial<BeautyProfile>): Promise<BeautyProfile>;
+        save(data: BeautyProfile): Promise<import("@firebase/firestore-types").DocumentReference<BeautyProfile>>;
+        buildCollectionPathForAdd(identifiers: Partial<BeautyProfile>): 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<BeautyProfile>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<BeautyProfile>;
+        buildModelInstance(): {
+            toFirestore: (data: BeautyProfile) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<BeautyProfile>) => BeautyProfile;
+        };
+    };
+};
 export declare class UserBeautyProfileFirestoreRepository extends UserBeautyProfileFirestoreRepository_base implements BeautyProfileRepository {
     readonly firestore: FirebaseFirestore;
     readonly parentRepository: UserFirestoreRepository;

package/infra/firebase/firestore/repositories/users/user-firestore.repository.d.ts

@@ -1,7 +1,48 @@
 import { DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
 import { User, UserRepository } from '../../../../../domain';
 import { UserSearchFirestoreRepository } from './user-search-firestore.repository';
-declare const UserFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<User> & import("../../../../../domain").CrudRepository<User, import("../../../../../domain").CrudParams<User>> & import("@infrab4a/connect").FirestoreHelpers, never>;
+declare const UserFirestoreRepository_base: {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<User>): Promise<User>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<User>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<User>): Partial<User>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<User>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<User>;
+        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<User>): Promise<User>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<User>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<User>[], limits?: import("../../../../../domain").RepositoryLimitOptions<User>, orderBy?: import("../../../../../domain").RepositoryOrderByList<User>): Promise<import("../../../../../domain").RepositoryFindResult<User>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<User>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<User> | import("@firebase/firestore-types").Query<User>, filter: import("../../../../../domain").RepositoryFindFielters<User>) => import("@firebase/firestore-types").Query<User>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<User> | import("@firebase/firestore-types").Query<User>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<User, import("../../../../../domain").NonFunctionPropertyNames<User>>) => import("@firebase/firestore-types").Query<User>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<User> | import("@firebase/firestore-types").Query<User>, filters: import("../../../../../domain").RepositoryFindFielters<User>[], limits: import("../../../../../domain").RepositoryLimitOptions<User>): Promise<import("@firebase/firestore-types").Query<User>>;
+        calculateCount(data: User[], limits: import("../../../../../domain").RepositoryLimitOptions<User>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<User>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<User>): string;
+        create(data: Partial<User>): Promise<User>;
+        save(data: User): Promise<import("@firebase/firestore-types").DocumentReference<User>>;
+        buildCollectionPathForAdd(identifiers: Partial<User>): 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<User>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<User>;
+        buildModelInstance(): {
+            toFirestore: (data: User) => DocumentData;
+            fromFirestore: (snap: QueryDocumentSnapshot<User>) => User;
+        };
+    };
+};
 export declare class UserFirestoreRepository extends UserFirestoreRepository_base implements UserRepository {
     readonly firestore: FirebaseFirestore;
     private readonly userSearchFirestoreRepository;

package/infra/firebase/firestore/repositories/users/user-payment-method-firestore.repository.d.ts

@@ -1,10 +1,57 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { User, UserPaymentMethod, UserPaymentMethodRepository } from '../../../../../domain';
 import { UserFirestoreRepository } from './user-firestore.repository';
-declare const UserPaymentMethodFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<UserPaymentMethod> & import("../../../../../domain").CrudRepository<UserPaymentMethod, import("../../../../../domain").CrudParams<UserPaymentMethod>> & import("@infrab4a/connect").FirestoreHelpers & {
-    readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
-    parentIdField: "id" | "userId";
-}, never>;
+declare const UserPaymentMethodFirestoreRepository_base: {
+    new (...args: any[]): {
+        readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
+        parentIdField: import("../../../../../domain").NonFunctionPropertyNames<UserPaymentMethod>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<UserPaymentMethod>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<UserPaymentMethod>;
+    };
+} & {
+    new (...args: any[]): {
+        update(data: import("../../../../../domain").RepositoryUpdateParams<UserPaymentMethod>): Promise<UserPaymentMethod>;
+        buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<UserPaymentMethod>): string;
+        paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<UserPaymentMethod>): Partial<UserPaymentMethod>;
+        readonly firestore?: FirebaseFirestore;
+        collectionName: string;
+        model: import("../../../../../domain").BaseModelBuilder<UserPaymentMethod>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<UserPaymentMethod>;
+        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<UserPaymentMethod>): Promise<UserPaymentMethod>;
+        buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<UserPaymentMethod>): string;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<UserPaymentMethod>[], limits?: import("../../../../../domain").RepositoryLimitOptions<UserPaymentMethod>, orderBy?: import("../../../../../domain").RepositoryOrderByList<UserPaymentMethod>): Promise<import("../../../../../domain").RepositoryFindResult<UserPaymentMethod>>;
+        buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<UserPaymentMethod>[]): string;
+        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<UserPaymentMethod> | import("@firebase/firestore-types").Query<UserPaymentMethod>, filter: import("../../../../../domain").RepositoryFindFielters<UserPaymentMethod>) => import("@firebase/firestore-types").Query<UserPaymentMethod>;
+        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<UserPaymentMethod> | import("@firebase/firestore-types").Query<UserPaymentMethod>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<UserPaymentMethod, import("../../../../../domain").NonFunctionPropertyNames<UserPaymentMethod>>) => import("@firebase/firestore-types").Query<UserPaymentMethod>;
+        defineLimits(query: import("@firebase/firestore-types").CollectionReference<UserPaymentMethod> | import("@firebase/firestore-types").Query<UserPaymentMethod>, filters: import("../../../../../domain").RepositoryFindFielters<UserPaymentMethod>[], limits: import("../../../../../domain").RepositoryLimitOptions<UserPaymentMethod>): Promise<import("@firebase/firestore-types").Query<UserPaymentMethod>>;
+        calculateCount(data: UserPaymentMethod[], limits: import("../../../../../domain").RepositoryLimitOptions<UserPaymentMethod>): number;
+        delete(identifiers: import("../../../../../domain").NonFunctionProperties<UserPaymentMethod>): Promise<void>;
+        buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<UserPaymentMethod>): string;
+        create(data: Partial<UserPaymentMethod>): Promise<UserPaymentMethod>;
+        save(data: UserPaymentMethod): Promise<import("@firebase/firestore-types").DocumentReference<UserPaymentMethod>>;
+        buildCollectionPathForAdd(identifiers: Partial<UserPaymentMethod>): 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<UserPaymentMethod>;
+        collection(path?: string): import("@firebase/firestore-types").CollectionReference<UserPaymentMethod>;
+        buildModelInstance(): {
+            toFirestore: (data: UserPaymentMethod) => import("@firebase/firestore-types").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<UserPaymentMethod>) => UserPaymentMethod;
+        };
+    };
+};
 export declare class UserPaymentMethodFirestoreRepository extends UserPaymentMethodFirestoreRepository_base implements UserPaymentMethodRepository {
     readonly firestore: FirebaseFirestore;
     readonly parentRepository: UserFirestoreRepository;

package/infra/firebase/firestore/repositories/users/user-search-firestore.repository.d.ts

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

package/infra/firebase/firestore/types/firestore-sub.repository.type.d.ts

@@ -1,6 +1,6 @@
 import { FirestoreRepository } from './firestore.repository.type';
-import { BaseModel, ModelBaseStructure, IdentifiersModel } from '../../../../domain';
-export declare type FirestoreSubRepository<Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure = BaseModel<{}>> = {
+import { BaseModelWithIdentifier, NonFunctionPropertyNames } from '../../../../domain';
+export declare type FirestoreSubRepository<Model extends BaseModelWithIdentifier<Model>, ParentModel extends BaseModelWithIdentifier<ParentModel> = BaseModelWithIdentifier<{}>> = {
     readonly parentRepository: FirestoreRepository<ParentModel>;
-    parentIdField: keyof IdentifiersModel<Model>;
+    parentIdField: NonFunctionPropertyNames<Model>;
 } & FirestoreRepository<Model>;

package/infra/firebase/firestore/types/firestore.helpers.type.d.ts

@@ -1,8 +1,8 @@
 import { QuerySnapshot, QueryDocumentSnapshot } from '@firebase/firestore-types';
-import { BaseModel } from '../../../../domain';
+import { BaseModelWithIdentifier } from '../../../../domain';
 import { FirestoreRepository } from './firestore.repository.type';
 import { FirestoreSubRepository } from './firestore-sub.repository.type';
 export interface FirestoreHelpers {
-    toArray<T extends BaseModel<T>>(snapShot: QuerySnapshot<T> | Array<QueryDocumentSnapshot<T>>): Array<T>;
-    isSubCollection<T extends BaseModel<T>>(repository: FirestoreRepository<T>): repository is FirestoreSubRepository<T>;
+    toArray<T extends BaseModelWithIdentifier<T>>(snapShot: QuerySnapshot<T> | Array<QueryDocumentSnapshot<T>>): Array<T>;
+    isSubCollection<T extends BaseModelWithIdentifier<T>>(repository: FirestoreRepository<T>): repository is FirestoreSubRepository<T>;
 }

package/infra/firebase/firestore/types/firestore.repository.type.d.ts

@@ -1,12 +1,8 @@
-import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
-import { BaseModelBuilder, ModelBaseStructure } from '../../../../domain';
-export declare type FirestoreRepository<Model extends ModelBaseStructure> = {
+import { CollectionReference, FirebaseFirestore } from '@firebase/firestore-types';
+import { BaseModelBuilder, BaseModelWithIdentifier } from '../../../../domain';
+export declare type FirestoreRepository<Model extends BaseModelWithIdentifier<Model>> = {
     readonly firestore?: FirebaseFirestore;
     collectionName: string;
     model: BaseModelBuilder<Model>;
     collection(path?: string): CollectionReference<Model>;
-    buildModelInstance(): {
-        toFirestore: (data: Model) => DocumentData;
-        fromFirestore: (snap: QueryDocumentSnapshot<Model>) => Model;
-    };
 };

package/infra/index.d.ts

@@ -1,3 +1,2 @@
 export * from './elasticsearch';
 export * from './firebase';
-export * from './hasura-graphql';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "1.0.0-beta.38",
+  "version": "1.0.0-beta.4",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -10,15 +10,13 @@
   },
   "dependencies": {
     "axios": "^0.27.2",
-    "class-transformer": "^0.5.1",
+    "class-transformer": "^0.4.0",
     "date-fns": "^2.28.0",
     "firebase": "7.24.0",
-    "gql-query-builder": "^3.7.0",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
-    "ts-custom-error": "3.2.2",
     "ts-md5": "^1.2.9",
-    "tslib": "^2.4.0"
+    "tslib": "^2.2.0"
   },
   "main": "bundles/infrab4a-connect.umd.js",
   "module": "fesm2015/infrab4a-connect.js",

package/utils/index.d.ts

@@ -1,7 +1,6 @@
-import { add, addDays, addBusinessDays, addMonths, addYears, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
-import { chunk, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set } from 'lodash';
+import { add, Duration, sub } from 'date-fns';
+import { chunk, get, isDate, isEmpty, isNil, isNumber, isObject, isString, pick, set } from 'lodash';
+export declare type DateDuration = Duration;
+export { add, chunk, get, isDate, isEmpty, isNil, isNumber, isObject, isString, pick, set, sub };
 export * from './mixins';
-export * from './is-uuid';
 export * from './types';
-export * from './parse-datetime';
-export { add, addDays, addBusinessDays, addMonths, addYears, chunk, endOfDay, format, formatISO9075, isBoolean, isDate, isEmpty, isInteger, isNil, isNaN, isNumber, isObject, isString, parseISO, now, omit, pick, set, startOfDay, sub, };

package/utils/mixins/index.d.ts

@@ -1,3 +1,2 @@
 export * from './mixin-ctor.type';
 export * from './base.mixin';
-export * from './merge-constructor-params.type';

package/utils/mixins/mixin-ctor.type.d.ts

@@ -1 +1 @@
-export declare type MixinCtor<T = any, A extends any[] = any[]> = new (...args: A) => T;
+export declare type MixinCtor<T = {}> = new (...args: Array<any>) => T;

package/utils/types/index.d.ts

@@ -1,2 +1 @@
 export * from './prop.type';
-export * from './array-element.type';

package/domain/catalog/models/kit-product.d.ts

@@ -1,12 +0,0 @@
-import { BaseModel } from '../../generic/model';
-import { Product } from './product';
-declare type KitProductIdentifiers = 'productId' | 'kitProducId';
-export declare class KitProduct extends BaseModel<KitProduct, KitProductIdentifiers> {
-    productId: string;
-    kitProductId: string;
-    quantity: number;
-    kit: Product;
-    product: Product;
-    static get identifiersFields(): KitProductIdentifiers[];
-}
-export {};

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

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

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

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

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

@@ -1,7 +0,0 @@
-import { ArrayElement, PropType } from '../../../../utils';
-import { ModelBaseStructure } from './model-base-structure.type';
-import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
-import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
-export declare type IdentifierModel<Model extends ModelBaseStructure> = ArrayElement<PropType<Model, 'identifiersFields'>>;
-export declare type IdentifiersModel<Model extends ModelBaseStructure> = Pick<NonFunctionAndIdentifierPropertiesWithNoPartial<Model>, Extract<NonFunctionAndIdentifierPropertyNames<Model>, IdentifierModel<Model>>>;
-export declare type PartialIdentifiersModel<Model extends ModelBaseStructure> = Partial<Pick<NonFunctionAndIdentifierPropertiesWithNoPartial<Model>, Extract<NonFunctionAndIdentifierPropertyNames<Model>, IdentifierModel<Model>>>>;

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

@@ -1,6 +0,0 @@
-import { NonFunctionAndIdentifierProperties } from './non-function-properties.type';
-export declare type ModelBaseStructure<M = any, I = any> = {
-    identifier: NonFunctionAndIdentifierProperties<M>;
-    identifiersFields: I[];
-    toPlain: any;
-};