@infrab4a/connect 4.0.0-beta.2 → 4.0.0-beta.21

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

@@ -4,8 +4,8 @@ import { GraphQLRepository } from '../types';
 import { CreateConstructorParams } from './with-create-hasura-graphql.mixin';
 import { DeleteConstructorParams } from './with-delete-hasura-graphql.mixin';
 import { GetConstructorParams } from './with-get-hasura-graphql.mixin';
-import { ConstructorParams } from './with-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>> & {
     paramsToPlain(params: import("../../../domain").RepositoryUpdateParams<TBase>): Partial<TBase>;
-}, MergeConstructorParams<[ConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+}, MergeConstructorParams<[HasuraConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,14 +1,9 @@
-import { ModelBaseStructure, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from '../../../domain';
+import { FindRepositoryParams, ModelBaseStructure, RepositoryFindResult } from '../../../domain';
 import { MixinCtor } from '../../../utils';
-import { GraphQLRepository } from '../types';
+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) => {
     new (...args: any[]): {
-        find(options?: {
-            filters?: RepositoryFindFielters<MBase>;
-            fields?: NonFunctionPropertyNames<MBase, keyof MBase>[];
-            limits?: RepositoryLimitOptions<MBase>;
-            orderBy?: RepositoryOrderBy<MBase>;
-        }): Promise<RepositoryFindResult<MBase>>;
+        find(params?: FindRepositoryParams<MBase>): Promise<RepositoryFindResult<MBase>>;
         tableName: string;
         model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
             prototype: unknown;
@@ -17,7 +12,7 @@ export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<an
         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>;
+        query: <ReturnFields_1 = any>(operation: string | 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>) => MBase;
         convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;

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

@@ -1,11 +1,22 @@
 import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields } from '../types';
-export declare type ConstructorParams<Model extends ModelBaseStructure> = {
+import { Fields, GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../types';
+declare type QueryBuilderOptions = {
+    operation: string;
+    fields: Fields;
+    variables?: VariableOptions;
+};
+declare type HasuraGraphQLInterceptors<P = QueryBuilderOptions | QueryBuilderOptions[]> = {
+    request?: <R>(request: P) => Promise<P & R>;
+    response?: <R>(response: R, request: P) => Promise<R>;
+};
+export declare type HasuraConstructorParams<Model extends ModelBaseStructure> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
     fields: HasuraGraphQLFields<Model>;
     endpoint: string;
+    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>, MergeConstructorParams<any[], ConstructorParameters<T>>>;
+export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, any[]>;
+export {};

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

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

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

@@ -0,0 +1,11 @@
+import { CategoryFilter } from '../../../../domain';
+import { CategoryFilterRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const CategoryFilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").GraphQLRepository<CategoryFilter> & import("../../../../domain").CrudRepository<CategoryFilter, import("../../../../domain").CrudParams<CategoryFilter>> & import("../../../../domain").UpdateRepository<CategoryFilter, import("../../../../domain").RepositoryUpdateParams<CategoryFilter>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryFilter>): Partial<CategoryFilter>;
+}, [HasuraConstructorParams<CategoryFilter> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class CategoryFilterHasuraGraphQLRepository extends CategoryFilterHasuraGraphQLRepository_base implements CategoryFilterRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any>;
+}
+export {};

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

@@ -1,27 +1,31 @@
 import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
 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>> & {
+declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").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[]]>;
+}, [HasuraConstructorParams<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;
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions, productRepository: ProductHasuraGraphQLRepository);
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
     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>;
-    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
+    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): 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;
 }
 export {};

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

@@ -0,0 +1,18 @@
+import { DeleteRepositoryParams, Filter, UpdateRepositoryParams } from '../../../../domain';
+import { FilterRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
+import { FilterOptionHasuraGraphQLRepository } from './filter-option-hasura-graphql.repository';
+declare const FilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").GraphQLRepository<Filter> & import("../../../../domain").CrudRepository<Filter, import("../../../../domain").CrudParams<Filter>> & import("../../../../domain").UpdateRepository<Filter, import("../../../../domain").RepositoryUpdateParams<Filter>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<Filter>): Partial<Filter>;
+}, [HasuraConstructorParams<Filter> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class FilterHasuraGraphQLRepository extends FilterHasuraGraphQLRepository_base implements FilterRepository {
+    private readonly filterOptionRepository;
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors'>, filterOptionRepository: FilterOptionHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    update(params: UpdateRepositoryParams<Filter>): Promise<Filter>;
+    updateOptions(filterId: number, { options }: Pick<UpdateRepositoryParams<Filter>, 'options'>): Promise<import("../../../../domain").FilterOption[]>;
+    delete(params: DeleteRepositoryParams<Filter>): Promise<void>;
+    deleteOptions(filterId: number): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { FilterOption } from '../../../../domain';
+import { FilterOptionRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").GraphQLRepository<FilterOption> & import("../../../../domain").CrudRepository<FilterOption, import("../../../../domain").CrudParams<FilterOption>> & import("../../../../domain").UpdateRepository<FilterOption, import("../../../../domain").RepositoryUpdateParams<FilterOption>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<FilterOption>): Partial<FilterOption>;
+}, [HasuraConstructorParams<FilterOption> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class FilterOptionHasuraGraphQLRepository extends FilterOptionHasuraGraphQLRepository_base implements FilterOptionRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors'>);
+}
+export {};

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

@@ -1,3 +1,6 @@
+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';

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

@@ -1,12 +1,12 @@
 import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductRepository, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
 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>> & {
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>): Partial<ProductHasuraGraphQL>;
-}, [import("../../mixins").ConstructorParams<ProductHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+}, [HasuraConstructorParams<ProductHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQLRepository_base implements ProductRepository {
     private get reviewsFields();
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions);
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>);
     create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     find(params?: FindRepositoryParams<ProductHasuraGraphQL>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
@@ -24,5 +24,6 @@ export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQL
     private getReviewByAuthorAndEmail;
     private bindReviewToModel;
     private bindReviewToHasura;
+    cleanShoppingCountFromIds(ids: string[]): Promise<void>;
 }
 export {};

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

@@ -1,11 +1,11 @@
 import { FindRepositoryParams, GetRepositoryParams, RepositoryFindResult, UpdateRepositoryParams, VariantRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
 import { VariantHasuraGraphQL } from '../../models';
-import { HasuraGraphQLAuthOptions } from '../../types';
-declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../../../domain").UpdateRepository<VariantHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>> & {
+declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../../../domain").UpdateRepository<VariantHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>> & {
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>): Partial<VariantHasuraGraphQL>;
-}, [import("../../mixins").ConstructorParams<VariantHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+}, [HasuraConstructorParams<VariantHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class VariantHasuraGraphQLRepository extends VariantHasuraGraphQLRepository_base implements VariantRepository {
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions);
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>);
     get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
     find(params?: FindRepositoryParams<VariantHasuraGraphQL>): Promise<RepositoryFindResult<VariantHasuraGraphQL>>;
     update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;

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

@@ -35,6 +35,6 @@ export declare type HasuraGraphQLFields<Model> = ((Model extends ModelBaseStruct
     [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>;
-} | (string & {}) : string) | {
+} | Record<string, ColumnOptions<PropType<Model, any>, Model>> | (string & {}) : string) | {
     aggregate: Array<AggregateOptions<Model> | 'count'>;
 } | 'affected_rows')[];

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@infrab4a/connect",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.21",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
-  "type": "commonjs",
   "repository": {
     "type": "git",
     "url": "https://github.com/B4AGroup/b4a-firebase-libs"

package/utils/index.d.ts

@@ -1,26 +1,6 @@
 import { add, addBusinessDays, addDays, addMonths, addYears, Duration, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
-import * as lodash from 'lodash';
+import { chunk, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set } from 'lodash';
 export declare type DateDuration = Duration;
-declare const chunk: <T>(array: lodash.List<T>, size?: number) => T[][], 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 './get';
 export * from './is';
 export * from './is-uuid';

package/domain/catalog/models/types/category-filter.type.d.ts

@@ -1,4 +0,0 @@
-export declare type CategoryFilter = {
-    name?: string;
-    tags?: string[];
-};

package/esm2020/domain/catalog/models/types/category-filter.type.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0ZWdvcnktZmlsdGVyLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9kb21haW4vY2F0YWxvZy9tb2RlbHMvdHlwZXMvY2F0ZWdvcnktZmlsdGVyLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIENhdGVnb3J5RmlsdGVyID0ge1xuICBuYW1lPzogc3RyaW5nXG4gIHRhZ3M/OiBzdHJpbmdbXVxufVxuIl19