@infrab4a/connect 1.0.0-beta.8 → 1.0.0-beta.9

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

@@ -1,57 +1,10 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { SubscriptionPayment, Subscription, SubscriptionPaymentRepository } from '../../../../../domain';
 import { SubscriptionFirestoreRepository } from './subscription-firestore.repository';
-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;
-        };
-    };
-};
+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>;
 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,57 +1,10 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { User, UserAddress, UserAddressRepository } from '../../../../../domain';
 import { UserFirestoreRepository } from './user-firestore.repository';
-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;
-        };
-    };
-};
+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>;
 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,57 +1,10 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { BeautyProfile, BeautyProfileRepository, User } from '../../../../../domain';
 import { UserFirestoreRepository } from './user-firestore.repository';
-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;
-        };
-    };
-};
+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>;
 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,48 +1,7 @@
 import { DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
 import { User, UserRepository } from '../../../../../domain';
 import { UserSearchFirestoreRepository } from './user-search-firestore.repository';
-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;
-        };
-    };
-};
+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>;
 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,57 +1,10 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { User, UserPaymentMethod, UserPaymentMethodRepository } from '../../../../../domain';
 import { UserFirestoreRepository } from './user-firestore.repository';
-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;
-        };
-    };
-};
+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>;
 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,48 +1,7 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
 import { CrudRepository } from '../../../../../domain';
 import { UserSearch } from '../../models/user-search';
-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;
-        };
-    };
-};
+declare const UserSearchFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<UserSearch> & CrudRepository<UserSearch, import("../../../../../domain").CrudParams<UserSearch>> & import("@infrab4a/connect").FirestoreHelpers, never>;
 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 { BaseModelWithIdentifier, NonFunctionPropertyNames } from '../../../../domain';
-export declare type FirestoreSubRepository<Model extends BaseModelWithIdentifier<Model>, ParentModel extends BaseModelWithIdentifier<ParentModel> = BaseModelWithIdentifier<{}>> = {
+import { BaseModel, ModelBaseStructure, IdentifiersModel } from '../../../../domain';
+export declare type FirestoreSubRepository<Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure = BaseModel<{}>> = {
     readonly parentRepository: FirestoreRepository<ParentModel>;
-    parentIdField: NonFunctionPropertyNames<Model>;
+    parentIdField: keyof IdentifiersModel<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 { BaseModelWithIdentifier } from '../../../../domain';
+import { BaseModel } from '../../../../domain';
 import { FirestoreRepository } from './firestore.repository.type';
 import { FirestoreSubRepository } from './firestore-sub.repository.type';
 export interface FirestoreHelpers {
-    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>;
+    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>;
 }

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

@@ -1,8 +1,12 @@
-import { CollectionReference, FirebaseFirestore } from '@firebase/firestore-types';
-import { BaseModelBuilder, BaseModelWithIdentifier } from '../../../../domain';
-export declare type FirestoreRepository<Model extends BaseModelWithIdentifier<Model>> = {
+import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { BaseModelBuilder, ModelBaseStructure } from '../../../../domain';
+export declare type FirestoreRepository<Model extends ModelBaseStructure> = {
     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/hasura-graphql/enums/hasura-graphql-column-type.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum HasuraGraphQLColumnType {
+    Int = "Int",
+    Float = "Float",
+    Boolean = "Boolean",
+    String = "String",
+    DateTime = "timestampz",
+    Json = "json",
+    Jsonb = "jsonb",
+    Enum = "enum",
+    Uuid = "uuid"
+}

package/infra/hasura-graphql/enums/hasura-graphql-where.enum.d.ts

@@ -0,0 +1,13 @@
+export declare enum HasuraGraphQLWhere {
+    EQUALS = "_eq",
+    GT = "_gt",
+    GTE = "_gte",
+    IN = "_in",
+    NOTIN = "_nin",
+    LT = "_lt",
+    LTE = "_lte",
+    LIKE = "_like",
+    NOTLIKE = "_nlike",
+    ISNULL = "_is_null",
+    ISNOTNULL = "_is_null"
+}

package/infra/hasura-graphql/enums/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hasura-graphql-where.enum';
+export * from './hasura-graphql-column-type.enum';

package/infra/hasura-graphql/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mixins';
+export * from './types';
+export * from './repositories';

package/infra/hasura-graphql/mixins/helpers/attribute-option.helper.d.ts

@@ -0,0 +1,10 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain';
+import { ColumnModelOptions, HasuraGrahphQLFields } from '../../types';
+export declare class AttributeOptionHelper {
+    static findByAttribute: <MBase extends ModelBaseStructure<any, any>, T extends ModelBaseStructure<any, any> = ModelBaseStructure<any, any>>(attributeName: NonFunctionAndIdentifierPropertyNames<MBase>, fields: HasuraGrahphQLFields<MBase>) => import("../../types").ColumnOptions<T, MBase, string | number | Record<string, any>> & {
+        fields?: HasuraGrahphQLFields<T>;
+        foreignKeyColumn?: { [key in NonFunctionAndIdentifierPropertyNames<T>]?: string; };
+    } & {
+        attributeName: NonFunctionAndIdentifierPropertyNames<MBase>;
+    };
+}

package/infra/hasura-graphql/mixins/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './attribute-option.helper';

package/infra/hasura-graphql/mixins/index.d.ts

@@ -0,0 +1,7 @@
+export * from './with-create-hasura-graphql.mixin';
+export * from './with-delete-hasura-graphql.mixin';
+export * from './with-hasura-graphql.mixin';
+export * from './with-update-hasura-graphql.mixin';
+export * from './with-get-hasura-graphql.mixin';
+export * from './with-find-hasura-graphql.mixin';
+export * from './with-crud-hasura-graphql.mixin';

package/infra/hasura-graphql/mixins/with-create-hasura-graphql.mixin.d.ts

@@ -0,0 +1,8 @@
+import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../domain';
+import { GraphQLRepository } from '../types';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+export declare type CreateConstructorParams = {
+    insertGraphQLOperation?: string;
+    insertGraphQLObjectType?: string;
+};
+export declare const withCreateHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & InstanceType<TMixinBase> & CreateRepository<MBase, CreateRepositoryParams<MBase>>, MergeConstructorParams<CreateConstructorParams, ConstructorParameters<TMixinBase>>>;

package/infra/hasura-graphql/mixins/with-crud-hasura-graphql.mixin.d.ts

@@ -0,0 +1,11 @@
+import { ModelBaseStructure, CrudRepository } from '../../../domain';
+import { GraphQLRepository } from '../types';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { CreateConstructorParams } from './with-create-hasura-graphql.mixin';
+import { ConstructorParams } from './with-hasura-graphql.mixin';
+import { DeleteConstructorParams } from './with-delete-hasura-graphql.mixin';
+import { GetConstructorParams } from './with-get-hasura-graphql.mixin';
+import { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType } from './with-update-hasura-graphql.mixin';
+export declare const withCrudHasuraGraphQL: <TBase extends ModelBaseStructure<any, any>, Repository = CrudRepository<TBase, import("../../../domain").CrudParams<TBase>>, TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<GraphQLRepository<TBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<TBase> & Repository & import("../../../domain").UpdateRepository<TBase, import("../../../domain").RepositoryUpdateParams<TBase>> & {
+    paramsToPlain(params: import("../../../domain").RepositoryUpdateParams<TBase>): Partial<TBase>;
+}, MergeConstructorParams<ConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ConstructorParameters<TMixinBase>>>;

package/infra/hasura-graphql/mixins/with-delete-hasura-graphql.mixin.d.ts

@@ -0,0 +1,7 @@
+import { DeleteRepository, DeleteRepositoryParams, ModelBaseStructure } from '../../../domain';
+import { GraphQLRepository } from '../types';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+export declare type DeleteConstructorParams = {
+    deleteGraphQLOperation?: string;
+};
+export declare const withDeleteHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & DeleteRepository<MBase, DeleteRepositoryParams<MBase>> & InstanceType<TMixinBase>, MergeConstructorParams<DeleteConstructorParams, ConstructorParameters<TMixinBase>>>;

package/infra/hasura-graphql/mixins/with-find-hasura-graphql.mixin.d.ts

@@ -0,0 +1,30 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from '../../../domain';
+import { ColumnOptions, GraphQLRepository, HasuraGrahphQLFields, VariableOptions } from '../types';
+import { HasuraGraphQLWhere } from '../enums';
+import { MixinCtor } from '../../../utils';
+export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+    new (...args: any[]): {
+        find(options?: {
+            filters?: RepositoryFindFielters<MBase>;
+            limits?: RepositoryLimitOptions<MBase>;
+            orderBy?: RepositoryOrderBy<MBase>;
+        }): Promise<RepositoryFindResult<MBase>>;
+        makeGraphQLWhere: (filter: RepositoryFindFielters<MBase>, fields: HasuraGrahphQLFields<MBase>) => VariableOptions;
+        buildWhereSentence: (field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fields: HasuraGrahphQLFields<MBase>) => VariableOptions;
+        buildOperatorSentence: (options: RepositoryFindFieltersOptions<MBase, any>, fieldOption: ColumnOptions<any, any>) => VariableOptions;
+        getHasuraOperator: (options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fieldOption: ColumnOptions<any, any>) => HasuraGraphQLWhere;
+        getHasuraJsonbOperator: (options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>) => HasuraGraphQLWhere;
+        tableName: string;
+        model: import("../../../domain").BaseModelBuilder<MBase, NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
+            prototype: unknown;
+        }>;
+        fields: HasuraGrahphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../types").HasuraGraphQLAuthOptions;
+        mutation: <ReturnFields = any>(operation: string, fields?: HasuraGrahphQLFields<MBase>, variables?: VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: HasuraGrahphQLFields<MBase>, variables?: VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura: (data: Record<string, string | number>) => MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;

package/infra/hasura-graphql/mixins/with-get-hasura-graphql.mixin.d.ts

@@ -0,0 +1,24 @@
+import { ModelBaseStructure, GetRepositoryParams } from '../../../domain';
+import { GraphQLRepository } from '../types';
+import { MixinCtor } from '../../../utils';
+export declare type GetConstructorParams = {
+    getGraphQLOperation?: string;
+};
+export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+    new (...params: any[]): {
+        getGraphQLOperation: string;
+        get(identifiers: GetRepositoryParams<MBase>): Promise<MBase>;
+        tableName: string;
+        model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
+            prototype: unknown;
+        }>;
+        fields: import("../types").HasuraGrahphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../types").HasuraGraphQLAuthOptions;
+        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGrahphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: import("../types").HasuraGrahphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura: (data: Record<string, string | number>) => MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;

package/infra/hasura-graphql/mixins/with-hasura-graphql.mixin.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGrahphQLFields } from '../types';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
+export declare type ConstructorParams<Model extends ModelBaseStructure> = {
+    tableName: string;
+    model: BaseModelBuilder<Model>;
+    fields: HasuraGrahphQLFields<Model>;
+    endpoint: string;
+    authOptions: HasuraGraphQLAuthOptions;
+};
+export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, MergeConstructorParams<ConstructorParams<MBase>, ConstructorParameters<T>>>;