@infrab4a/connect 4.0.0-beta.26 → 4.0.0-beta.28

package/infra/elasticsearch/adapters/axios.adapter.d.ts

@@ -1,11 +1,11 @@
-import { BaseModel } from '../../../domain';
+import { ModelBaseStructure } from '../../../domain';
 import { ElasticSearchResult } from '../types/elastic-search-result';
 import { ElasticSearchAdapter } from './elastic-search.adapter';
 export declare type AxiosElasticSearchConfig = {
     url: string;
     credential: string;
 };
-export declare class AxiosAdapter<T extends BaseModel<T>> implements ElasticSearchAdapter<T> {
+export declare class AxiosAdapter<T extends ModelBaseStructure<T>> implements ElasticSearchAdapter<T> {
     private readonly config;
     constructor(config: AxiosElasticSearchConfig);
     get(index: string, id: string): Promise<T>;

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

@@ -1,4 +1,4 @@
 import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { MixinCtor } from '../../../../utils';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-export declare const withCreateFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & CreateRepository<TBase, CreateRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<[], ConstructorParameters<TMixinBase>>>;
+export declare const withCreateFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & CreateRepository<TBase, CreateRepositoryParams<TBase>> & FirestoreHelpers, []>;

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

@@ -2,4 +2,4 @@ import { CrudRepository, ModelBaseStructure } from '../../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../../utils';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
 import { FirestoreConstructorParams } from './with-firestore.mixin';
-export declare const withCrudFirestore: <TBase extends ModelBaseStructure<any, any>, Repository = CrudRepository<TBase, import("../../../../domain").CrudParams<TBase>>, TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & Repository & FirestoreHelpers, MergeConstructorParams<[FirestoreConstructorParams<TBase>, ...any[]], ConstructorParameters<TMixinBase>>>;
+export declare const withCrudFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, Repository = CrudRepository<TBase, import("../../../../domain").CrudParams<TBase>>, TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & Repository & FirestoreHelpers, MergeConstructorParams<[FirestoreConstructorParams<TBase>, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,4 +1,4 @@
 import { DeleteRepository, DeleteRepositoryParams, ModelBaseStructure } from '../../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { MixinCtor } from '../../../../utils';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-export declare const withDeleteFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & DeleteRepository<TBase, DeleteRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}[], ConstructorParameters<TMixinBase>>>;
+export declare const withDeleteFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & DeleteRepository<TBase, DeleteRepositoryParams<TBase>> & FirestoreHelpers, []>;

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

@@ -1,4 +1,4 @@
 import { FindRepository, ModelBaseStructure } from '../../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { MixinCtor } from '../../../../utils';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-export declare const withFindFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & FindRepository<TBase, import("../../../../domain").FindRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}[], ConstructorParameters<TMixinBase>>>;
+export declare const withFindFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & FindRepository<TBase, import("../../../../domain").FindRepositoryParams<TBase>> & FirestoreHelpers, []>;

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

@@ -3,11 +3,11 @@ import { BaseModelBuilder, ModelBaseStructure, NonFunctionAndIdentifierPropertyN
 import { MergeConstructorParams, MixinCtor } from '../../../../utils';
 import { FirestoreFieldType } from '../enums';
 import { FirestoreInterceptors, FirestoreRepository } from '../types';
-export declare type FirestoreConstructorParams<Model extends ModelBaseStructure> = {
+export declare type FirestoreConstructorParams<Model extends ModelBaseStructure<Model>> = {
     firestore: Firestore;
     collectionName: string;
     model: BaseModelBuilder<Model>;
     fields?: Partial<Record<NonFunctionAndIdentifierPropertyNames<Model>, FirestoreFieldType>>;
     interceptors?: FirestoreInterceptors<Model>;
 };
-export declare const withFirestore: <TBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<FirestoreRepository<TBase>, any[]>;
+export declare const withFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<FirestoreRepository<TBase>, any[]>;

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

@@ -1,4 +1,4 @@
 import { GetRepository, ModelBaseStructure } from '../../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { MixinCtor } from '../../../../utils';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-export declare const withGetFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & GetRepository<TBase, import("../../../../domain").GetRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}[], ConstructorParameters<TMixinBase>>>;
+export declare const withGetFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & GetRepository<TBase, import("../../../../domain").GetRepositoryParams<TBase>> & FirestoreHelpers, []>;

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

@@ -5,7 +5,7 @@ import { FirestoreRepository, FirestoreSubRepository } from '../types';
 export declare const withHelpers: <TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<any, any[]> & TMixinBase) => {
     new (...args: any[]): {
         [x: string]: any;
-        toArray<T extends ModelBaseStructure<any, any>>(snapShot: QuerySnapshot<T> | QueryDocumentSnapshot<T>[]): T[];
-        isSubCollection<T_1 extends ModelBaseStructure<any, any>>(repository: FirestoreRepository<T_1>): repository is FirestoreSubRepository<T_1, import("../../../../domain").BaseModel<{}, "id">>;
+        toArray<T extends ModelBaseStructure<T, T["identifiersFields"][number]>>(snapShot: QuerySnapshot<T> | QueryDocumentSnapshot<T>[]): T[];
+        isSubCollection<T_1 extends ModelBaseStructure<T_1, T_1["identifiersFields"][number]>, E extends ModelBaseStructure<E, E["identifiersFields"][number]>>(repository: FirestoreRepository<T_1> | FirestoreSubRepository<T_1, E>): repository is FirestoreSubRepository<T_1, E>;
     };
 } & TMixinBase;

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

@@ -5,7 +5,7 @@ import { FirestoreConstructorParams } from './with-firestore.mixin';
 export declare type FirestoreSubCollectionConstructorParams<TBase extends ModelBaseStructure> = {
     parentIdField: keyof IdentifiersModel<TBase>;
 };
-export declare const withSubCollection: <TBase extends ModelBaseStructure<any, any>, TBaseParent extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase>, any[]> & TMixinBase, ParentModel: new () => TBaseParent) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & {
+export declare const withSubCollection: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TBaseParent extends ModelBaseStructure<TBaseParent, TBaseParent["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase>, any[]> & TMixinBase, ParentModel: new () => TBaseParent) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & {
     readonly parentRepository: FirestoreRepository<TBaseParent>;
-    parentIdField: Extract<import("../../../../domain").NonFunctionAndIdentifierPropertyNames<TBase>, import("../../../../utils").ArrayElement<import("../../../../utils").PropType<TBase, "identifiersFields">>>;
+    parentIdField: Extract<import("../../../../domain").NonFunctionAndIdentifierPropertyNames<TBase>, import("../../../../utils").PropType<TBase, "identifiersFields">[number]>;
 } & FirestoreHelpers, MergeConstructorParams<[FirestoreConstructorParams<TBase> & FirestoreSubCollectionConstructorParams<TBase>, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,7 +1,7 @@
 import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } from '../../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { MixinCtor } from '../../../../utils';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
-export declare type UpdateFirestoreRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {
+export declare type UpdateFirestoreRepositoryType<MBase extends ModelBaseStructure<MBase>> = UpdateRepository<MBase> & {
     paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
 };
-export declare const withUpdateFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & UpdateRepository<TBase, RepositoryUpdateParams<TBase>> & InstanceType<TMixinBase> & FirestoreHelpers, MergeConstructorParams<{}[], ConstructorParameters<TMixinBase>>>;
+export declare const withUpdateFirestore: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & UpdateRepository<TBase, RepositoryUpdateParams<TBase>> & InstanceType<TMixinBase> & FirestoreHelpers, []>;

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';
-import { BaseModel, ModelBaseStructure, IdentifiersModel } from '../../../../domain';
-export declare type FirestoreSubRepository<Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure = BaseModel<{}>> = {
+export declare type FirestoreSubRepository<Model extends ModelBaseStructure<Model>, ParentModel extends ModelBaseStructure<ParentModel>> = {
     readonly parentRepository: FirestoreRepository<ParentModel>;
-    parentIdField: keyof IdentifiersModel<Model>;
+    parentIdField: IdentifierModel<Model>;
 } & FirestoreRepository<Model>;

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

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

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

@@ -2,7 +2,7 @@ import { CollectionReference, DocumentData, Firestore, QueryDocumentSnapshot } f
 import { BaseModelBuilder, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain';
 import { FirestoreFieldType } from '../enums';
 import { FirestoreInterceptors } from './firestore-interceptors.type';
-export declare type FirestoreRepository<Model extends ModelBaseStructure> = {
+export declare type FirestoreRepository<Model extends ModelBaseStructure<Model>> = {
     readonly firestore?: Firestore;
     collectionName: string;
     model: BaseModelBuilder<Model>;

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

@@ -4,9 +4,15 @@ declare type FindByAttributeResult<MBase extends ModelBaseStructure<MBase>, Attr
     attributeName: Attribute;
 };
 export declare class AttributeOptionHelper {
-    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> & {
+    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: any) => fieldValue is ColumnOptions<Model, ParentModel, any>;
+    static FindColumnOptionFromList: <Model extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>, ParentModel extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: 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<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;
+    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, NonFunctionAndIdentifierPropertyNames<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;
 }

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

@@ -1,6 +1,8 @@
 import { ModelBaseStructure, RepositoryFindFieltersOptions } from '../../../../domain';
 import { ColumnOptions } from '../../types';
 export declare class FilterOptionHelper {
-    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;
+    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;
 }

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

@@ -1,8 +1,11 @@
-import { ModelBaseStructure, NonFunctionProperties } from '../../../../domain';
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoPartial, PartialIdentifiersModel } from '../../../../domain';
 import { Fields, GraphQLParams, HasuraGraphQLFields } from '../../types';
 export declare class GraphQLFieldHelper {
-    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;
+    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<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>, RecordDataType extends string | number | Date | DataType, DataType extends Record<string, RecordDataType | RecordDataType[]>>(data: 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;
 }

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

@@ -3,6 +3,7 @@ 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<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>>>;
+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, ...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 { HasuraConstructorParams } from './with-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>> & {
+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>> & {
     paramsToPlain(params: import("../../../domain").RepositoryUpdateParams<TBase>): Partial<TBase>;
 }, MergeConstructorParams<[HasuraConstructorParams<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<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>>>;
+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, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,20 +1,22 @@
-import { FindRepositoryParams, ModelBaseStructure, RepositoryFindResult } from '../../../domain';
-import { MixinCtor } from '../../../utils';
-import { GraphQLParams, GraphQLRepository } from '../types';
-export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+import { FindRepositoryParams, ModelBaseStructure, 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) => {
     new (...args: any[]): {
         find(params?: FindRepositoryParams<MBase>): Promise<RepositoryFindResult<MBase>>;
+        bindOrderByAttributes: (orderBy: RepositoryOrderBy<MBase>, fields: HasuraGraphQLFields<MBase>) => {};
         tableName: string;
-        model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
+        model: import("../../../domain").BaseModelBuilder<MBase, any, MBase & {
             prototype: unknown;
         }>;
-        fields: import("../types").HasuraGraphQLFields<MBase>;
+        fields: HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | GraphQLParams<MBase>[], fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        logger: DebugHelper;
+        mutation: <ReturnFields = any>(operation: string, fields?: string[] | HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | GraphQLParams<MBase>[], fields?: string[] | HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
         getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-        convertDataFromHasura: (data: Record<string, string | number>) => MBase;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<MBase>): MBase;
         convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
     };
 } & TMixinBase;

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

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

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

@@ -10,7 +10,7 @@ declare type HasuraGraphQLInterceptors<P = QueryBuilderOptions | QueryBuilderOpt
     request?: <R>(request: P) => Promise<P & R>;
     response?: <R>(response: R, request: P) => Promise<R>;
 };
-export declare type HasuraConstructorParams<Model extends ModelBaseStructure> = {
+export declare type HasuraConstructorParams<Model extends ModelBaseStructure<Model, Model['identifiersFields'][number]>> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
     fields: HasuraGraphQLFields<Model>;
@@ -18,5 +18,5 @@ export declare type HasuraConstructorParams<Model extends ModelBaseStructure> =
     interceptors?: HasuraGraphQLInterceptors;
     authOptions: HasuraGraphQLAuthOptions;
 };
-export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, any[]>;
+export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, any[]>;
 export {};

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> = UpdateRepository<MBase> & {
+export declare type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>> = 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<any, any>, 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<MBase, MBase["identifiersFields"][number]>, 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, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,21 +1,23 @@
 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> = {
+export declare type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
     operation: string;
     fields?: HasuraGraphQLFields<Model>;
     variables?: VariableOptions;
 };
-export declare type GraphQLRepository<Model extends ModelBaseStructure> = {
+export declare type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
     fields: HasuraGraphQLFields<Model>;
     endpoint: string;
     authOptions: HasuraGraphQLAuthOptions;
-    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>;
+    logger: DebugHelper;
+    mutation: <ReturnFields = any>(operation: string, fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    query: <ReturnFields = any>(operation: string | GraphQLParams<Model>[], fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
     getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-    convertDataFromHasura: (data: Record<string, string | number>) => Model;
+    convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): 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 extends any[] ? FieldType[number] : FieldType>;
+    fields?: HasuraGraphQLFields<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,10 +31,14 @@ export declare type AggregateOptions<Model> = {
     var_samp?: Array<AggregateOptionFields<Model, number>>;
     variance?: Array<AggregateOptionFields<Model, number>>;
 };
-export declare type HasuraGraphQLFields<Model> = ((Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
+declare type ModelBaseHasuraGraphQLFields<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 & {}) : string) | {
+} | Record<string, ColumnOptions<PropType<Model, any>, Model>> : string;
+export declare type HasuraGraphQLFields<Model> = (ModelBaseHasuraGraphQLFields<Model> | {
     aggregate: Array<AggregateOptions<Model> | 'count'>;
+} | {
+    returning: NonFunctionAndIdentifierPropertyNames<Model>[];
 } | 'affected_rows')[];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "4.0.0-beta.26",
+  "version": "4.0.0-beta.28",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -12,6 +12,7 @@
     "axios": "^0.27.2",
     "class-transformer": "^0.5.1",
     "date-fns": "^2.28.0",
+    "debug": "^4.3.4",
     "firebase": "^9.9.0",
     "gql-query-builder": "3.7.0",
     "lodash": "^4.17.21",

package/utils/decorators/debug.class.decorator.d.ts

@@ -0,0 +1,2 @@
+import { DebugOptions } from '../helpers';
+export declare function Debug(opts?: DebugOptions): ClassDecorator;

package/utils/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './debug.class.decorator';
+export * from './trace.method.decorator';

package/utils/decorators/trace.method.decorator.d.ts

@@ -0,0 +1,14 @@
+export declare type CallbackFnArgs<T, Result> = {
+    target: T;
+    result: Result;
+    args: Array<any>;
+    namespace?: Array<string>;
+};
+declare type CallbackFn<T, Result> = (opts: CallbackFnArgs<T, Result>) => void;
+declare type TraceOptions<T, Result> = {
+    callbackFn?: CallbackFn<T, Result>;
+    level?: 'trace' | 'log';
+};
+export declare function Log<T, Result>(options?: TraceOptions<T, Result>): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Trace<T, Result>(options?: TraceOptions<T, Result>): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export {};

package/utils/helpers/class-name.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class ClassNameHelper {
+    static get(clazz: any): string;
+}

package/utils/helpers/debug-decorator.helper.d.ts

@@ -0,0 +1,9 @@
+export declare type DebugOptions = {
+    name?: string;
+    namespaces?: Array<string>;
+};
+export declare class DebugDecoratorHelper {
+    static DebugNamingMetadataKey: string;
+    static set(target: object, options: DebugOptions): void;
+    static get(target: object): DebugOptions;
+}

package/utils/helpers/debug.helper.d.ts

@@ -0,0 +1,60 @@
+import { Debugger } from 'debug';
+import { Subject } from 'rxjs';
+export declare type Debuggable = {
+    debug: DebugHelper;
+};
+declare type DebugLog = {
+    namespace: string;
+    message: string;
+    args: Array<any>;
+};
+declare type DebugError = {
+    namespace: string;
+    error: any;
+    args: Array<any>;
+};
+export declare const isDebuggable: (object: any) => object is Debuggable;
+export declare class DebugHelper {
+    static logs$: Subject<DebugLog>;
+    static traces$: Subject<DebugLog>;
+    static errors$: Subject<DebugError>;
+    static isDebuggable: (object: any) => object is Debuggable;
+    static namespacesFor(target: object): Array<string>;
+    static as(...namespaces: Array<string>): DebugHelper;
+    static for(target: object, ...namespaces: Array<string>): DebugHelper;
+    static from(target: object, ...namespaces: Array<string>): DebugHelper;
+    static clonedFrom(target: object, ...namespaces: Array<string>): DebugHelper;
+    static clone(target: object, ...namespaces: Array<string>): {
+        original: DebugHelper;
+        debug: DebugHelper;
+    };
+    static replace(target: any, attrs: {
+        with: DebugHelper;
+    }): void;
+    static mock(target: object, ...namespaces: Array<string>): {
+        original: DebugHelper;
+        debug: DebugHelper;
+    };
+    logger: Debugger;
+    tracer: Debugger;
+    err: Debugger;
+    namespaces: Set<string>;
+    constructor(...namespace: Array<string>);
+    get entries(): Array<string>;
+    get namespace(): string;
+    log(message?: any, ...args: Array<any>): DebugHelper;
+    trace(message?: any, ...args: Array<any>): DebugHelper;
+    error(error: any, ...args: Array<any>): DebugHelper;
+    build(): DebugHelper;
+    with(...namespace: Array<string>): DebugHelper;
+    push(...namespace: Array<string>): DebugHelper;
+    unshift(...namespace: Array<string>): DebugHelper;
+    reset(...namespace: Array<string>): DebugHelper;
+    startWith(...namespace: Array<string>): DebugHelper;
+    shift(): DebugHelper;
+    pop(): DebugHelper;
+    clear(): DebugHelper;
+    remove(...namespace: Array<string>): DebugHelper;
+    puts(...args: Array<string>): string;
+}
+export {};

package/utils/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './debug.helper';
+export * from './reflect.helper';
+export * from './class-name.helper';
+export * from './debug-decorator.helper';