@infrab4a/connect 3.16.0-beta.1 → 4.0.0-beta.0

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

@@ -1,9 +1,9 @@
-import { DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { DocumentData, Firestore, QueryDocumentSnapshot } from 'firebase/firestore';
 import { User, UserRepository } from '../../../../../domain';
-declare const UserFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<User> & import("../../../../../domain").CrudRepository<User, import("../../../../../domain").CrudParams<User>> & import("@infrab4a/connect").FirestoreHelpers, []>;
+declare const UserFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<User> & import("../../../../../domain").CrudRepository<User, import("../../../../../domain").CrudParams<User>> & import("@infrab4a/connect").FirestoreHelpers, {}[]>;
 export declare class UserFirestoreRepository extends UserFirestoreRepository_base implements UserRepository {
-    readonly firestore: FirebaseFirestore;
-    constructor(firestore: FirebaseFirestore);
+    readonly firestore: Firestore;
+    constructor(firestore: Firestore);
     get(identifiers: Partial<User>): Promise<User>;
     checkIfExistsByField(field: string, value: string): Promise<boolean>;
     buildModelInstance(): {

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

@@ -1,13 +1,13 @@
-import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Firestore } from 'firebase/firestore';
 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";
-}, []>;
+}, {}[][]>;
 export declare class UserPaymentMethodFirestoreRepository extends UserPaymentMethodFirestoreRepository_base implements UserPaymentMethodRepository {
-    readonly firestore: FirebaseFirestore;
+    readonly firestore: Firestore;
     readonly parentRepository: UserFirestoreRepository;
-    constructor(firestore: FirebaseFirestore, parentRepository: UserFirestoreRepository);
+    constructor(firestore: Firestore, parentRepository: UserFirestoreRepository);
 }
 export {};

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

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

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

@@ -1,8 +1,8 @@
-import { QueryDocumentSnapshot, QuerySnapshot } from '@firebase/firestore-types';
-import { ModelBaseStructure } from '../../../../domain';
-import { FirestoreSubRepository } from './firestore-sub.repository.type';
+import { QuerySnapshot, QueryDocumentSnapshot } from 'firebase/firestore';
+import { BaseModel } from '../../../../domain';
 import { FirestoreRepository } from './firestore.repository.type';
+import { FirestoreSubRepository } from './firestore-sub.repository.type';
 export interface FirestoreHelpers {
-    toArray<T extends ModelBaseStructure<T>>(snapShot: QuerySnapshot<T> | Array<QueryDocumentSnapshot<T>>): Array<T>;
-    isSubCollection<T extends ModelBaseStructure<T>, E extends ModelBaseStructure<E>>(repository: FirestoreRepository<T> | FirestoreSubRepository<T, E>): repository is FirestoreSubRepository<T, E>;
+    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,8 @@
-import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { CollectionReference, DocumentData, Firestore, QueryDocumentSnapshot } from 'firebase/firestore';
 import { BaseModelBuilder, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain';
 import { FirestoreFieldType } from '../enums';
-export declare type FirestoreRepository<Model extends ModelBaseStructure<Model>> = {
-    readonly firestore?: FirebaseFirestore;
+export declare type FirestoreRepository<Model extends ModelBaseStructure> = {
+    readonly firestore?: Firestore;
     collectionName: string;
     model: BaseModelBuilder<Model>;
     collection(path?: string): CollectionReference<Model>;

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

@@ -9,5 +9,7 @@ export declare enum HasuraGraphQLWhere {
     LIKE = "_like",
     NOTLIKE = "_nlike",
     ISNULL = "_is_null",
-    ISNOTNULL = "_is_null"
+    ISNOTNULL = "_is_null",
+    JSON_CONTAINS = "_contains",
+    JSON_HAS_KEYS_ANY = "_has_keys_any"
 }

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

@@ -4,11 +4,9 @@ declare type FindByAttributeResult<MBase extends ModelBaseStructure<MBase>, Attr
     attributeName: Attribute;
 };
 export declare class AttributeOptionHelper {
-    static FindByAttribute: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase> = NonFunctionAndIdentifierPropertyNames<MBase>>(attributeName: Attribute, fields: HasuraGraphQLFields<MBase>) => FindByAttributeResult<MBase, Attribute>;
-    static CheckIsColumnOption: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>, ParentModel extends ModelBaseStructure<Record<string, any> & {
-        identifiersFields: any[];
-    }, any>>(fieldValue: ColumnOptions<Model, ParentModel, any>) => fieldValue is ColumnOptions<Model, ParentModel, any>;
-    static FindColumnOptionFromList: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>, ParentModel extends ModelBaseStructure<ParentModel, ParentModel["identifiersFields"][number]>>(columnName: string, fields: HasuraGraphQLFields<ParentModel>) => ColumnOptions<Model, ParentModel, any> & {
+    static FindByAttribute: <MBase extends ModelBaseStructure<any, any>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase> = NonFunctionAndIdentifierPropertyNames<MBase>>(attributeName: Attribute, fields: HasuraGraphQLFields<MBase>) => FindByAttributeResult<MBase, Attribute>;
+    static CheckIsColumnOption: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(fieldValue: any) => fieldValue is ColumnOptions<Model, ParentModel, any>;
+    static FindColumnOptionFromList: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(columnName: string, fields: HasuraGraphQLFields<ParentModel>) => ColumnOptions<Model, ParentModel, any> & {
         attributeName: NonFunctionAndIdentifierPropertyNames<ParentModel>;
     };
 }

package/infra/hasura-graphql/mixins/helpers/bind-filter-query.helper.d.ts

@@ -2,9 +2,9 @@ import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionP
 import { HasuraGraphQLWhere } from '../../enums';
 import { ColumnOptions, HasuraGraphQLFields, VariableOptions } from '../../types';
 export declare class BindFilterQueryHelper {
-    static MakeGraphQLWhere: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(filter: RepositoryFindFielters<MBase>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
-    static BuildWhereSentence: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, MBase, Exclude<keyof MBase, import("../../../../domain").ReadonlyKeys<MBase>>>>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
-    static BuildOperatorSentence: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(options: RepositoryFindFieltersOptions<MBase, any>, fieldOption: ColumnOptions<any, any>) => VariableOptions;
-    static GetHasuraOperator: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, MBase, Exclude<keyof MBase, import("../../../../domain").ReadonlyKeys<MBase>>>>, fieldOption: ColumnOptions<any, any>) => HasuraGraphQLWhere;
-    static GetHasuraJsonbOperator: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, MBase, Exclude<keyof MBase, import("../../../../domain").ReadonlyKeys<MBase>>>>) => HasuraGraphQLWhere;
+    static MakeGraphQLWhere: <MBase extends ModelBaseStructure<any, any>>(filter: RepositoryFindFielters<MBase>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
+    static BuildWhereSentence: <MBase extends ModelBaseStructure<any, any>>(field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
+    static BuildOperatorSentence: <MBase extends ModelBaseStructure<any, any>>(options: RepositoryFindFieltersOptions<MBase, any>, fieldOption: ColumnOptions<any, any>) => VariableOptions;
+    static GetHasuraOperator: <MBase extends ModelBaseStructure<any, any>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fieldOption: ColumnOptions<any, any>) => HasuraGraphQLWhere;
+    static GetHasuraJsonbOperator: <MBase extends ModelBaseStructure<any, any>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>) => HasuraGraphQLWhere;
 }

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

@@ -1,8 +1,6 @@
 import { ModelBaseStructure, RepositoryFindFieltersOptions } from '../../../../domain';
 import { ColumnOptions } from '../../types';
 export declare class FilterOptionHelper {
-    static CheckIfIsFilterOption: <Model extends ModelBaseStructure<Record<string, any> & {
-        identifiersFields: any[];
-    }, any>>(filter: any) => filter is RepositoryFindFieltersOptions<Model, any>;
-    static GetValueFromFilter: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>>(filter: RepositoryFindFieltersOptions<Model, any>, fieldOption: ColumnOptions<any, any>) => any;
+    static CheckIfIsFilterOption: <Model extends ModelBaseStructure<any, any>>(filter: any) => filter is RepositoryFindFieltersOptions<Model, any>;
+    static GetValueFromFilter: <Model extends ModelBaseStructure<any, any>>(filter: RepositoryFindFieltersOptions<Model, any>, fieldOption: ColumnOptions<any, any>) => any;
 }

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

@@ -1,9 +1,8 @@
-import { ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoPartial, PartialIdentifiersModel } from '../../../../domain';
+import { ModelBaseStructure, NonFunctionProperties } from '../../../../domain';
 import { Fields, GraphQLParams, HasuraGraphQLFields } from '../../types';
 export declare class GraphQLFieldHelper {
-    static CheckIsGraphQLParams: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>>(params: string | GraphQLParams<Model>[]) => params is GraphQLParams<Model>[];
-    static ConvertModelFieldsToGraphQLFields: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>>(fields: HasuraGraphQLFields<Model>) => Fields;
-    static ConvertFieldValueFrom: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>, DataType extends Record<string, string | number | Date | DataType>>(data: string | number | Date | DataType, fields: HasuraGraphQLFields<Model>) => NonFunctionAndIdentifierPropertiesWithNoPartial<Model> | Partial<import("../../../../domain").IdentifiersModel<Model>>;
-    static ConvertFieldValueTo: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>, DataType extends Record<string, string | number | Date | DataType>>(instance: Model, fields: HasuraGraphQLFields<Model>, update?: boolean) => DataType;
-    private static ConvertNestedFieldsToGraphQLFields;
+    static CheckIsGraphQLParams: <Model extends ModelBaseStructure<any, any>>(params: string | GraphQLParams<Model>[]) => params is GraphQLParams<Model>[];
+    static ConvertModelFieldsToGraphQLFields: <Model extends ModelBaseStructure<any, any>>(fields: HasuraGraphQLFields<Model>) => Fields;
+    static ConvertFieldValueFrom: <Model extends ModelBaseStructure<any, any>, RecordDataType extends string | number | Date | DataType, DataType extends Record<string, RecordDataType | RecordDataType[]>>(data: DataType, fields: HasuraGraphQLFields<Model>) => Partial<NonFunctionProperties<Model>>;
+    static ConvertFieldValueTo: <Model extends ModelBaseStructure<any, any>, DataType extends Record<string, string | number | Date | DataType>>(instance: Model, fields: HasuraGraphQLFields<Model>, update?: boolean) => DataType;
 }

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

@@ -3,7 +3,6 @@ import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
 export declare type CreateConstructorParams = {
     insertGraphQLOperation?: string;
-    insertAllGraphQLOperation?: string;
     insertGraphQLObjectType?: string;
 };
-export declare const withCreateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, 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>>>;
+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, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -6,6 +6,6 @@ import { DeleteConstructorParams } from './with-delete-hasura-graphql.mixin';
 import { GetConstructorParams } from './with-get-hasura-graphql.mixin';
 import { ConstructorParams } from './with-hasura-graphql.mixin';
 import { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType } from './with-update-hasura-graphql.mixin';
-export declare const withCrudHasuraGraphQL: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, 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>> & {
+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>>>;
+}, MergeConstructorParams<[ConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -4,4 +4,4 @@ import { GraphQLRepository } from '../types';
 export declare type DeleteConstructorParams = {
     deleteGraphQLOperation?: string;
 };
-export declare const withDeleteHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, 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>>>;
+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, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,34 +1,25 @@
-import { FindRepositoryParams, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, RepositoryFindResult, RepositoryOrderBy } from '../../../domain';
-import { DebugHelper, MixinCtor } from '../../../utils';
-import { GraphQLParams, GraphQLRepository, HasuraGraphQLFields } from '../types';
-export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+import { ModelBaseStructure, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from '../../../domain';
+import { MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
+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(params?: FindRepositoryParams<MBase>): Promise<RepositoryFindResult<MBase>>;
-        bindOrderByAttributes: (orderBy: RepositoryOrderBy<MBase>, fields: HasuraGraphQLFields<MBase>) => {};
-        bindAggretageAttributes: (aggregates: {
-            minimal?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-            maximum?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-        }, fields: HasuraGraphQLFields<MBase>) => ({
-            min: {}[];
-            max?: undefined;
-        } | {
-            max: {}[];
-            min?: undefined;
-        })[];
-        bindDistinctAttributes: (distinct: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[], fields: HasuraGraphQLFields<MBase>) => {}[];
-        bindAttributesToColumns: (attributes: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[], fields: HasuraGraphQLFields<MBase>) => {}[];
+        find(options?: {
+            filters?: RepositoryFindFielters<MBase>;
+            fields?: NonFunctionPropertyNames<MBase, keyof MBase>[];
+            limits?: RepositoryLimitOptions<MBase>;
+            orderBy?: RepositoryOrderBy<MBase>;
+        }): Promise<RepositoryFindResult<MBase>>;
         tableName: string;
-        model: import("../../../domain").BaseModelBuilder<MBase, any, MBase & {
+        model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
             prototype: unknown;
         }>;
-        fields: HasuraGraphQLFields<MBase>;
+        fields: import("../types").HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        logger: DebugHelper;
-        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: string[] | HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | GraphQLParams<MBase>[], fields?: string[] | HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
         getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<MBase>): MBase;
+        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

@@ -1,25 +1,24 @@
 import { GetRepositoryParams, ModelBaseStructure } from '../../../domain';
-import { DebugHelper, MixinCtor } from '../../../utils';
+import { MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
 export declare type GetConstructorParams = {
     getGraphQLOperation?: string;
 };
-export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+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, any, MBase & {
+        model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
             prototype: unknown;
         }>;
         fields: import("../types").HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        logger: DebugHelper;
-        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: string[] | import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../types").GraphQLParams<MBase>[], fields?: string[] | import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
         getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | import("../types").HasuraGraphQLFields<MBase>): MBase;
+        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

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

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

@@ -1,7 +1,7 @@
 import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-export declare type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>> = UpdateRepository<MBase> & {
+export declare type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {
     paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
 };
 export declare type UpdateConstructorParams = {
@@ -9,6 +9,6 @@ export declare type UpdateConstructorParams = {
     updateGraphQLObjectType?: string;
     updateGraphQLPKType?: string;
 };
-export declare const withUpdateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateRepository<MBase, RepositoryUpdateParams<MBase>> & {
+export declare const withUpdateHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateRepository<MBase, RepositoryUpdateParams<MBase>> & {
     paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
-} & InstanceType<TMixinBase>, MergeConstructorParams<UpdateConstructorParams, ConstructorParameters<TMixinBase>>>;
+} & InstanceType<TMixinBase>, MergeConstructorParams<[UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/infra/hasura-graphql/models/product-hasura-graphql.d.ts

@@ -10,9 +10,5 @@ export declare class ProductHasuraGraphQL extends Product {
     whoMustUse?: string;
     howToUse?: string;
     brandDescription?: string;
-    categoryId?: number;
-    ingredients?: string;
-    hasStock?: boolean;
-    intGender?: number;
     kitProducts?: KitProductHasuraGraphQL[];
 }

package/infra/hasura-graphql/models/variant-hasura-graphql.d.ts

@@ -4,7 +4,6 @@ export declare class VariantHasuraGraphQL extends Variant {
     fullPrice?: number;
     subscriberDiscountPercentage?: number;
     subscriberPrice?: number;
-    hasStock?: boolean;
     name?: string;
     hasVariants?: boolean;
 }

package/infra/hasura-graphql/repositories/catalog/category-hasura-graphql.repository.d.ts

@@ -1,34 +1,27 @@
 import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams } from '../../../../domain';
 import { CategoryHasuraGraphQL } from '../../models';
 import { HasuraGraphQLAuthOptions } from '../../types';
-import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
 import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
 declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<CategoryHasuraGraphQL> & import("../../../../domain").CrudRepository<CategoryHasuraGraphQL, import("../../../../domain").CrudParams<CategoryHasuraGraphQL>> & import("../../../../domain").UpdateRepository<CategoryHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<CategoryHasuraGraphQL>> & {
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryHasuraGraphQL>): Partial<CategoryHasuraGraphQL>;
 }, [import("../../mixins").ConstructorParams<CategoryHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
     private readonly productRepository;
-    private readonly categoryFilterRepository;
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions, productRepository: ProductHasuraGraphQLRepository);
     create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
-    getCategoryByShop(shop: string): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): Promise<{
+    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
         category: Category;
         products: Product[];
     }[]>;
     mountCategory(category: Category, options?: {
         limit?: number;
         hasStock?: boolean;
-        gender?: string;
     }): Promise<Product[]>;
     private getId;
     private updateProducts;
     private updateMetadata;
-    private updateFilters;
-    getChildren(parentId: number): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
 }
 export {};

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

@@ -1,8 +1,3 @@
-export * from './category-collection-children-hasura-graphql.repository';
-export * from './category-filter-hasura-graphql.repository';
 export * from './category-hasura-graphql.repository';
-export * from './filter-hasura-graphql.repository';
-export * from './filter-option-hasura-graphql.repository';
 export * from './product-hasura-graphql.repository';
 export * from './variant-hasura-graphql.repository';
-export * from './wishlist-hasura-graphql.repository';

package/infra/hasura-graphql/repositories/catalog/product-hasura-graphql.repository.d.ts

@@ -1,4 +1,4 @@
-import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductGender, ProductRepository, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductRepository, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
 import { ProductHasuraGraphQL } from '../../models';
 import { HasuraGraphQLAuthOptions } from '../../types';
 declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<ProductHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductHasuraGraphQL, import("../../../../domain").CrudParams<ProductHasuraGraphQL>> & import("../../../../domain").UpdateRepository<ProductHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>> & {
@@ -13,7 +13,6 @@ export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQL
     getBySlug(slug: string): Promise<ProductHasuraGraphQL>;
     update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
-    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
     private updateCategories;
     private updateKitProducts;
     private updateReviews;
@@ -25,6 +24,5 @@ export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQL
     private getReviewByAuthorAndEmail;
     private bindReviewToModel;
     private bindReviewToHasura;
-    cleanShoppingCountFromIds(ids: string[]): Promise<void>;
 }
 export {};

package/infra/hasura-graphql/types/graphql.repository.type.d.ts

@@ -1,24 +1,21 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
 import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
-import { DebugHelper } from '../../../utils';
 import { HasuraGraphQLAuthOptions } from './hasura-graphql-auth-options.type';
 import { HasuraGraphQLFields } from './hasura-graphql-fields.type';
 import { VariableOptions } from './variable-options.type';
-export declare type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
-    operation: string | IOperation;
+export declare type GraphQLParams<Model extends ModelBaseStructure> = {
+    operation: string;
     fields?: HasuraGraphQLFields<Model>;
     variables?: VariableOptions;
 };
-export declare type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
+export declare type GraphQLRepository<Model extends ModelBaseStructure> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
     fields: HasuraGraphQLFields<Model>;
     endpoint: string;
     authOptions: HasuraGraphQLAuthOptions;
-    logger: DebugHelper;
-    mutation: <ReturnFields = any>(operation: string | IOperation, fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
-    query: <ReturnFields = any>(operation: string | IOperation | GraphQLParams<Model>[], fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    mutation: <ReturnFields = any>(operation: string, fields?: HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    query: <ReturnFields = any>(operation: string | GraphQLParams<Model>[], fields?: HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
     getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-    convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): Model;
+    convertDataFromHasura: (data: Record<string, string | number>) => Model;
     convertDataToHasura(instance: Model, update?: boolean): Record<string, string | number>;
 };

package/infra/hasura-graphql/types/hasura-graphql-fields.type.d.ts

@@ -8,7 +8,7 @@ export declare type ColumnOptions<FieldType, Model, ValueFrom = any> = {
         filterType: HasuraGraphQLColumnType | string;
         filters: NestedRepositoryFindFieltersOptions<FieldType>;
     };
-    fields?: HasuraGraphQLFields<FieldType>;
+    fields?: HasuraGraphQLFields<FieldType extends any[] ? FieldType[number] : FieldType>;
     foreignKeyColumn?: Partial<Record<NonFunctionAndIdentifierPropertyNames<FieldType extends any[] ? FieldType[number] : FieldType>, NonFunctionAndIdentifierPropertyNames<Model> | (string & {})>> | {};
     from?: (value: ValueFrom | ValueFrom[], data?: any) => FieldType;
     to?: (value: FieldType, instance?: Model) => ValueFrom;
@@ -31,14 +31,10 @@ export declare type AggregateOptions<Model> = {
     var_samp?: Array<AggregateOptionFields<Model, number>>;
     variance?: Array<AggregateOptionFields<Model, number>>;
 };
-declare type ModelBaseHasuraGraphQLFields<Model> = Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
+export declare type HasuraGraphQLFields<Model> = ((Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
     [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? HasuraGraphQLFields<PropType<Model, key>> : PropType<Model, key> extends any[] ? PropType<Model, key>[] extends ModelBaseStructure[] ? HasuraGraphQLFields<PropType<Model, key>[]> : never : never;
 } | {
     [key in NonFunctionAndIdentifierPropertyNames<Model>]?: key extends 'aggregate' ? never : PropType<Model, key> extends ModelBaseStructure ? ColumnOptions<PropType<Model, key>, Model> : ColumnOptions<PropType<Model, key>, Model>;
-} | Record<string, ColumnOptions<PropType<Model, any>, Model>> : string;
-export declare type HasuraGraphQLFields<Model> = (ModelBaseHasuraGraphQLFields<Model> | {
+} | (string & {}) : string) | {
     aggregate: Array<AggregateOptions<Model> | 'count'>;
-} | {
-    returning: NonFunctionAndIdentifierPropertyNames<Model>[];
 } | 'affected_rows')[];
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "3.16.0-beta.1",
+  "version": "4.0.0-beta.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -12,8 +12,7 @@
     "axios": "^0.27.2",
     "class-transformer": "^0.5.1",
     "date-fns": "^2.28.0",
-    "debug": "^4.3.4",
-    "firebase": "7.24.0",
+    "firebase": "^9.9.0",
     "gql-query-builder": "3.7.0",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
@@ -21,11 +20,24 @@
     "ts-md5": "^1.2.9",
     "tslib": "^2.4.0"
   },
-  "main": "bundles/infrab4a-connect.umd.js",
-  "module": "fesm2015/infrab4a-connect.js",
-  "es2015": "fesm2015/infrab4a-connect.js",
-  "esm2015": "esm2015/infrab4a-connect.js",
-  "fesm2015": "fesm2015/infrab4a-connect.js",
-  "typings": "infrab4a-connect.d.ts",
+  "module": "fesm2015/infrab4a-connect.mjs",
+  "es2020": "fesm2020/infrab4a-connect.mjs",
+  "esm2020": "esm2020/infrab4a-connect.mjs",
+  "fesm2020": "fesm2020/infrab4a-connect.mjs",
+  "fesm2015": "fesm2015/infrab4a-connect.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2020": "./esm2020/infrab4a-connect.mjs",
+      "es2020": "./fesm2020/infrab4a-connect.mjs",
+      "es2015": "./fesm2015/infrab4a-connect.mjs",
+      "node": "./fesm2015/infrab4a-connect.mjs",
+      "default": "./fesm2020/infrab4a-connect.mjs"
+    }
+  },
   "sideEffects": false
 }

package/utils/index.d.ts

@@ -1,10 +1,50 @@
-import { add, addBusinessDays, addDays, addMonths, addYears, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
-import { chunk, each, get, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set, unset } from 'lodash';
-export * from './decorators';
-export * from './helpers';
+import { add, addBusinessDays, addDays, addMonths, addYears, Duration, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
+import * as lodash from 'lodash';
+export declare type DateDuration = Duration;
+declare const chunk: <T>(array: lodash.List<T>, size?: number) => T[][], get: {
+    <TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
+    <TObject_1 extends object, TKey_1 extends keyof TObject_1>(object: TObject_1, path: TKey_1 | [TKey_1]): TObject_1[TKey_1];
+    <TObject_2 extends object, TKey_2 extends keyof TObject_2, TDefault>(object: TObject_2, path: TKey_2 | [TKey_2], defaultValue: TDefault): TDefault | Exclude<TObject_2[TKey_2], undefined>;
+    <TObject_3 extends object, TKey1 extends keyof TObject_3, TKey2 extends keyof TObject_3[TKey1]>(object: TObject_3, path: [TKey1, TKey2]): TObject_3[TKey1][TKey2];
+    <TObject_4 extends object, TKey1_1 extends keyof TObject_4, TKey2_1 extends keyof TObject_4[TKey1_1]>(object: TObject_4, path: [TKey1_1, TKey2_1]): TObject_4[TKey1_1][TKey2_1];
+    <TObject_5 extends object, TKey1_2 extends keyof TObject_5, TKey2_2 extends keyof TObject_5[TKey1_2], TDefault_1>(object: TObject_5, path: [TKey1_2, TKey2_2], defaultValue: TDefault_1): TDefault_1 | Exclude<TObject_5[TKey1_2][TKey2_2], undefined>;
+    <TObject_6 extends object, TKey1_3 extends keyof TObject_6, TKey2_3 extends keyof TObject_6[TKey1_3], TKey3 extends keyof TObject_6[TKey1_3][TKey2_3]>(object: TObject_6, path: [TKey1_3, TKey2_3, TKey3]): TObject_6[TKey1_3][TKey2_3][TKey3];
+    <TObject_7 extends object, TKey1_4 extends keyof TObject_7, TKey2_4 extends keyof TObject_7[TKey1_4], TKey3_1 extends keyof TObject_7[TKey1_4][TKey2_4]>(object: TObject_7, path: [TKey1_4, TKey2_4, TKey3_1]): TObject_7[TKey1_4][TKey2_4][TKey3_1];
+    <TObject_8 extends object, TKey1_5 extends keyof TObject_8, TKey2_5 extends keyof TObject_8[TKey1_5], TKey3_2 extends keyof TObject_8[TKey1_5][TKey2_5], TDefault_2>(object: TObject_8, path: [TKey1_5, TKey2_5, TKey3_2], defaultValue: TDefault_2): TDefault_2 | Exclude<TObject_8[TKey1_5][TKey2_5][TKey3_2], undefined>;
+    <TObject_9 extends object, TKey1_6 extends keyof TObject_9, TKey2_6 extends keyof TObject_9[TKey1_6], TKey3_3 extends keyof TObject_9[TKey1_6][TKey2_6], TKey4 extends keyof TObject_9[TKey1_6][TKey2_6][TKey3_3]>(object: TObject_9, path: [TKey1_6, TKey2_6, TKey3_3, TKey4]): TObject_9[TKey1_6][TKey2_6][TKey3_3][TKey4];
+    <TObject_10 extends object, TKey1_7 extends keyof TObject_10, TKey2_7 extends keyof TObject_10[TKey1_7], TKey3_4 extends keyof TObject_10[TKey1_7][TKey2_7], TKey4_1 extends keyof TObject_10[TKey1_7][TKey2_7][TKey3_4]>(object: TObject_10, path: [TKey1_7, TKey2_7, TKey3_4, TKey4_1]): TObject_10[TKey1_7][TKey2_7][TKey3_4][TKey4_1];
+    <TObject_11 extends object, TKey1_8 extends keyof TObject_11, TKey2_8 extends keyof TObject_11[TKey1_8], TKey3_5 extends keyof TObject_11[TKey1_8][TKey2_8], TKey4_2 extends keyof TObject_11[TKey1_8][TKey2_8][TKey3_5], TDefault_3>(object: TObject_11, path: [TKey1_8, TKey2_8, TKey3_5, TKey4_2], defaultValue: TDefault_3): TDefault_3 | Exclude<TObject_11[TKey1_8][TKey2_8][TKey3_5][TKey4_2], undefined>;
+    <T>(object: lodash.NumericDictionary<T>, path: number): T;
+    <T_1>(object: lodash.NumericDictionary<T_1>, path: number): T_1;
+    <T_2, TDefault_4>(object: lodash.NumericDictionary<T_2>, path: number, defaultValue: TDefault_4): T_2 | TDefault_4;
+    <TDefault_5>(object: null, path: lodash.PropertyPath, defaultValue: TDefault_5): TDefault_5;
+    (object: null, path: lodash.PropertyPath): undefined;
+    <TObject_12, TPath extends string>(data: TObject_12, path: TPath): string extends TPath ? any : lodash.GetFieldType<TObject_12, TPath>;
+    <TObject_13, TPath_1 extends string, TDefault_6 = lodash.GetFieldType<TObject_13, TPath_1>>(data: TObject_13, path: TPath_1, defaultValue: TDefault_6): TDefault_6 | Exclude<lodash.GetFieldType<TObject_13, TPath_1>, null>;
+    (object: any, path: lodash.PropertyPath, defaultValue?: any): any;
+}, isBoolean: (value?: any) => value is boolean, isDate: (value?: any) => value is Date, isEmpty: {
+    <T extends {
+        __trapAny: any;
+    }>(value?: T): boolean;
+    (value: string): value is "";
+    (value: Map<any, any> | Set<any> | lodash.List<any>): boolean;
+    (value: object): boolean;
+    <T_1 extends object>(value: T_1): value is lodash.EmptyObjectOf<T_1>;
+    (value?: any): boolean;
+}, isInteger: (value?: any) => boolean, isNaN: (value?: any) => boolean, isNil: (value: any) => value is null, isNumber: (value?: any) => value is number, isObject: (value?: any) => value is object, isString: (value?: any) => value is string, now: () => number, omit: {
+    <T extends object, K extends lodash.PropertyName[]>(object: T, ...paths: K): Pick<T, Exclude<keyof T, K[number]>>;
+    <T_1 extends object, K_1 extends keyof T_1>(object: T_1, ...paths: lodash.Many<K_1>[]): lodash.Omit<T_1, K_1>;
+    <T_2 extends object>(object: T_2, ...paths: lodash.Many<lodash.PropertyName>[]): Partial<T_2>;
+}, pick: {
+    <T extends object, U extends keyof T>(object: T, ...props: lodash.Many<U>[]): Pick<T, U>;
+    <T_1>(object: T_1, ...props: lodash.Many<lodash.PropertyPath>[]): Partial<T_1>;
+}, set: {
+    <T extends object>(object: T, path: lodash.PropertyPath, value: any): T;
+    <TResult>(object: object, path: lodash.PropertyPath, value: any): TResult;
+};
+export * from './is';
 export * from './is-uuid';
-export * from './log.utils';
 export * from './mixins';
 export * from './parse-datetime';
 export * from './types';
-export { add, addDays, addBusinessDays, addMonths, addYears, chunk, each, endOfDay, format, formatISO9075, get, isBoolean, isDate, isEmpty, isInteger, isNil, isNaN, isNumber, isObject, isString, parseISO, now, omit, pick, set, startOfDay, sub, unset, };
+export { add, addDays, addBusinessDays, addMonths, addYears, chunk, get, endOfDay, format, formatISO9075, isBoolean, isDate, isEmpty, isInteger, isNil, isNaN, isNumber, isObject, isString, parseISO, now, omit, pick, set, startOfDay, sub, };

package/utils/is.d.ts

@@ -0,0 +1 @@
+export declare function is<T>(value: any): T;

package/utils/mixins/merge-constructor-params.type.d.ts

@@ -1,3 +1,3 @@
-declare type Tail<T extends any[]> = T extends [any, ...infer U] ? U : never;
-export declare type MergeConstructorParams<NewParams, CurrentParams extends any[]> = CurrentParams extends [] ? [NewParams, ...any] : CurrentParams[0] extends never ? [NewParams, ...any] : [CurrentParams[0] & NewParams, ...Tail<CurrentParams>];
+declare type Tail<T extends any[]> = T extends [any, ...infer U] ? U : [];
+export declare type MergeConstructorParams<NewParams extends any[], CurrentParams extends any[]> = CurrentParams extends [] ? [...NewParams, ...any] : CurrentParams[0] extends never ? [...NewParams, ...any] : [...NewParams, ...Tail<CurrentParams>];
 export {};