@infrab4a/connect 4.29.0 → 4.30.0

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

@@ -1,6 +0,0 @@
-import { ProductErrors } from '../../../domain';
-import { ProductHasuraGraphQL } from './product-hasura-graphql';
-import { VariantHasuraGraphQL } from './variant-hasura-graphql';
-export declare class ProductErrorsHasuraGraphQL extends ProductErrors<ProductHasuraGraphQL | VariantHasuraGraphQL> {
-    product: ProductHasuraGraphQL | VariantHasuraGraphQL;
-}

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

@@ -1,18 +0,0 @@
-import { Product } from '../../../domain';
-import { KitProductHasuraGraphQL } from './kit-product-hasura-graphql';
-export declare class ProductHasuraGraphQL extends Product {
-    firestoreId?: string;
-    fullPrice?: number;
-    subscriberDiscountPercentage?: number;
-    subscriberPrice?: number;
-    productId?: number;
-    differentials?: string;
-    whoMustUse?: string;
-    howToUse?: string;
-    brandDescription?: string;
-    categoryId?: number;
-    ingredients?: string;
-    hasStock?: boolean;
-    intGender?: number;
-    kitProducts?: KitProductHasuraGraphQL[];
-}

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

@@ -1,8 +0,0 @@
-import { Variant } from '../../../domain';
-export declare class VariantHasuraGraphQL extends Variant {
-    firestoreId?: string;
-    fullPrice?: number;
-    subscriberDiscountPercentage?: number;
-    subscriberPrice?: number;
-    hasStock?: boolean;
-}

package/src/infra/hasura-graphql/models/wishlist-hasura-graphql.d.ts

@@ -1,4 +0,0 @@
-import { Wishlist } from '../../../domain';
-export declare class WishlistHasuraGraphQL extends Wishlist {
-    personHasPhoto?: boolean;
-}

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

@@ -1,10 +0,0 @@
-import { CategoryCollectionChildren } from '../../../../domain';
-import { CategoryCollectionChildrenRepository } from '../../../../domain/catalog/repositories/category-collection-children.repository';
-import { HasuraConstructorParams } from '../../mixins';
-declare const CategoryCollectionChildrenHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryCollectionChildren> & import("../../../../domain").CrudRepository<CategoryCollectionChildren, import("../../../../domain").CrudParams<CategoryCollectionChildren>> & import("../../../../domain").UpdateRepository<CategoryCollectionChildren, import("../../../../domain").RepositoryUpdateParams<CategoryCollectionChildren>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryCollectionChildren>): Partial<CategoryCollectionChildren>;
-}, [HasuraConstructorParams<CategoryCollectionChildren> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class CategoryCollectionChildrenHasuraGraphQLRepository extends CategoryCollectionChildrenHasuraGraphQLRepository_base implements CategoryCollectionChildrenRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryCollectionChildren>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-}
-export {};

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

@@ -1,13 +0,0 @@
-import { CategoryFilter } from '../../../../domain';
-import { CategoryFilterRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-declare const CategoryFilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").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, cache, }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    addFiltersToCategory(categoryId: number, filterIds: number[]): Promise<void>;
-    deleteByCategory(categoryId: number): Promise<any>;
-    deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any>;
-}
-export {};

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

@@ -1,48 +0,0 @@
-import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, RepositoryCacheOptions, Shops, UpdateRepositoryParams } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { CategoryHasuraGraphQL } from '../../models';
-import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
-import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
-declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").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>;
-}, [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;
-    private readonly categoryFilterRepository;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
-    create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<CategoryHasuraGraphQL>;
-    update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
-    getCategoryBySlug(slug: string, shop: Shops, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category>;
-    getCategoryByShop(shop: string, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<{
-        category: Category;
-        products: Product[];
-    }[]>;
-    mountCategory(category: Category, shop: Shops, options?: {
-        limit?: number;
-        hasStock?: boolean;
-        gender?: string;
-    }, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Product[]>;
-    getChildren(parentId: number, _optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
-    private getId;
-    private updateProducts;
-    private updateMetadata;
-    private updateFilters;
-    private saveToCache;
-    private reorganizeMostRelevantsProducts;
-}
-export {};

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

@@ -1,16 +0,0 @@
-import { CategoryProduct, CategoryProductRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-declare const CategoryProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryProduct> & import("../../../../domain").CrudRepository<CategoryProduct, import("../../../../domain").CrudParams<CategoryProduct>> & import("../../../../domain").UpdateRepository<CategoryProduct, import("../../../../domain").RepositoryUpdateParams<CategoryProduct>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryProduct>): Partial<CategoryProduct>;
-}, [HasuraConstructorParams<CategoryProduct> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class CategoryProductHasuraGraphQLRepository extends CategoryProductHasuraGraphQLRepository_base implements CategoryProductRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    removeProductsFromCategory(categoryId: string, productIds: string[]): Promise<void>;
-    removeProductFromCategories(productId: string, categoryIds: string[]): Promise<void>;
-    addProductsToCategory(categoryId: string, productIds: {
-        productId: string;
-        order: number;
-    }[]): Promise<void>;
-    addProductToCategories(productId: string, categoryIds: string[]): Promise<void>;
-}
-export {};

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

@@ -1,18 +0,0 @@
-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("../..").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, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, 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/src/infra/hasura-graphql/repositories/catalog/filter-option-hasura-graphql.repository.d.ts

@@ -1,10 +0,0 @@
-import { FilterOption } from '../../../../domain';
-import { FilterOptionRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").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, cache, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-}
-export {};

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

@@ -1,12 +0,0 @@
-export * from './category-collection-children-hasura-graphql.repository';
-export * from './category-filter-hasura-graphql.repository';
-export * from './category-hasura-graphql.repository';
-export * from './category-product-hasura-graphql.repository';
-export * from './filter-hasura-graphql.repository';
-export * from './filter-option-hasura-graphql.repository';
-export * from './product-errors-hasura-graphql.repository';
-export * from './product-hasura-graphql.repository';
-export * from './product-review-hasura-graphql.repository';
-export * from './product-stock-notification-hasura-graphql.repository';
-export * from './variant-hasura-graphql.repository';
-export * from './wishlist-hasura-graphql.repository';

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

@@ -1,15 +0,0 @@
-import { FindRepositoryParams, GetRepositoryParams } from '../../../../domain';
-import { ProductErrorsRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-import { ProductErrorsHasuraGraphQL } from '../../models';
-import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
-declare const ProductErrorsHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductErrorsHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").CrudParams<ProductErrorsHasuraGraphQL>> & import("../../../../domain").UpdateRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductErrorsHasuraGraphQL>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductErrorsHasuraGraphQL>): Partial<ProductErrorsHasuraGraphQL>;
-}, [HasuraConstructorParams<ProductErrorsHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductErrorsHasuraGraphQLRepository extends ProductErrorsHasuraGraphQLRepository_base implements ProductErrorsRepository {
-    private readonly productRepository;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, productRepository: ProductHasuraGraphQLRepository);
-    get(params: GetRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<ProductErrorsHasuraGraphQL>;
-    find(params: FindRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<import("../../../../domain").RepositoryFindResult<ProductErrorsHasuraGraphQL>>;
-}
-export {};

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

@@ -1,44 +0,0 @@
-import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, PaginatedReviewFilters, ProductGender, ProductRepository, ProductVariantReport, RepositoryCacheOptions, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { ProductHasuraGraphQL } from '../../models';
-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>;
-}, [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, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ProductHasuraGraphQL>;
-    find(params?: FindRepositoryParams<ProductHasuraGraphQL>, optionsParams?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-    getBySlug(slug: string, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ProductHasuraGraphQL>;
-    update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    fetchProductReviews(filters: PaginatedReviewFilters, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ReviewWithProductData[]>;
-    fetchReviews(status: ReviewStatusParams, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ReviewWithProductData[]>;
-    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-    cleanShoppingCountFromIds(ids: string[]): Promise<void>;
-    private getReviewStatus;
-    private updateKitProducts;
-    private updateReviews;
-    private updateMetadata;
-    private getId;
-    private findReviewsByProduct;
-    private findReview;
-    private getReviewByPersonId;
-    private getReviewByAuthorAndEmail;
-    private bindReviewToModel;
-    private bindReviewToHasura;
-    productVariantFullReport(): Promise<ProductVariantReport[]>;
-}
-export {};

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

@@ -1,13 +0,0 @@
-import { ProductReview } from '../../../../domain';
-import { ProductReviewRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-declare const ProductReviewHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductReview> & import("../../../../domain").CrudRepository<ProductReview, import("../../../../domain").CrudParams<ProductReview>> & import("../../../../domain").UpdateRepository<ProductReview, import("../../../../domain").RepositoryUpdateParams<ProductReview>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductReview>): Partial<ProductReview>;
-}, [HasuraConstructorParams<ProductReview> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductReviewHasuraGraphQLRepository extends ProductReviewHasuraGraphQLRepository_base implements ProductReviewRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductReview>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    updateManyStatus(reviews: Pick<ProductReview, 'id' | 'status'>[]): Promise<void>;
-    aproveReview(id: number): Promise<ProductReview>;
-    disaproveReview(id: number): Promise<ProductReview>;
-}
-export {};

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

@@ -1,18 +0,0 @@
-import { Filter, ProductStockNotification, ReportStockNotification, ReportStockNotificationInput, RepositoryFindResult, Shops } from '../../../../domain';
-import { ProductStockNotificationRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-declare const ProductStockNotificationHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductStockNotification> & import("../../../../domain").CrudRepository<ProductStockNotification, import("../../../../domain").CrudParams<ProductStockNotification>> & import("../../../../domain").UpdateRepository<ProductStockNotification, import("../../../../domain").RepositoryUpdateParams<ProductStockNotification>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductStockNotification>): Partial<ProductStockNotification>;
-}, [HasuraConstructorParams<ProductStockNotification> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductStockNotificationHasuraGraphQLRepository extends ProductStockNotificationHasuraGraphQLRepository_base implements ProductStockNotificationRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    addCustomerEmail(shop: Shops, productId: string, name: string, email: string): Promise<void>;
-    getNotificationsReport(params: ReportStockNotificationInput, orderBy: {
-        field: string;
-        direction: string;
-    }, pagination?: {
-        offset: number;
-        limit: number;
-    }): Promise<RepositoryFindResult<ReportStockNotification>>;
-}
-export {};

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

@@ -1,14 +0,0 @@
-import { FindRepositoryParams, GetRepositoryParams, RepositoryFindResult, UpdateRepositoryParams, VariantRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { VariantHasuraGraphQL } from '../../models';
-declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").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>;
-}, [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, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
-    find(params?: FindRepositoryParams<VariantHasuraGraphQL>): Promise<RepositoryFindResult<VariantHasuraGraphQL>>;
-    update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
-    private getId;
-}
-export {};

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

@@ -1,31 +0,0 @@
-import { Category, CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, Product, RepositoryFindResult, Shops, UpdateRepositoryParams, Wishlist, WishlistRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { WishlistHasuraGraphQL } from '../../models/wishlist-hasura-graphql';
-import { CategoryProductHasuraGraphQLRepository } from './category-product-hasura-graphql.repository';
-declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<WishlistHasuraGraphQL> & import("../../../../domain").CrudRepository<WishlistHasuraGraphQL, import("../../../../domain").CrudParams<WishlistHasuraGraphQL>> & import("../../../../domain").UpdateRepository<WishlistHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<WishlistHasuraGraphQL>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<WishlistHasuraGraphQL>): Partial<WishlistHasuraGraphQL>;
-}, [HasuraConstructorParams<WishlistHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class WishlistHasuraGraphQLRepository extends WishlistHasuraGraphQLRepository_base implements WishlistRepository {
-    private readonly categoryProductRepository;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, categoryProductRepository: CategoryProductHasuraGraphQLRepository);
-    create(params: CreateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
-    find(params?: FindRepositoryParams<WishlistHasuraGraphQL>): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
-    update(params: UpdateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
-    getWishlistBySlug(slug: string): Promise<WishlistHasuraGraphQL>;
-    getWishlistByPerson(personId: string): Promise<WishlistHasuraGraphQL[]>;
-    getCategoryBySlug(slug: string, _shop: Shops): Promise<Wishlist>;
-    getCategoryByShop(shop: string): Promise<any>;
-    findBfluOrGlamgirlWishlists(params: FindRepositoryParams<WishlistHasuraGraphQL>, shops: Shops[]): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
-    getCategoriesForHome(categoryIds: string[], gender?: string, limit?: number): any;
-    mountCategory(category: Category, shop: Shops, options?: {
-        limit?: number;
-        hasStock?: boolean;
-    }): Promise<Product[]>;
-    getChildren(parentId: number): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
-    private updateMetadata;
-    addProduct(wishlistId: string, productId: string): Promise<void>;
-    removeProduct(wishlistId: string, productId: string): Promise<void>;
-}
-export {};

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

@@ -1 +0,0 @@
-export * from './catalog';

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

@@ -1,2 +0,0 @@
-import { NestedField } from './nested-field.type';
-export type Fields = Array<string | object | NestedField | 'aggregate' | 'nodes'>;

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

@@ -1,25 +0,0 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
-import { BaseModelBuilder, CacheConfig, 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 type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
-    operation: string | IOperation;
-    fields?: HasuraGraphQLFields<Model>;
-    variables?: VariableOptions;
-};
-export type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
-    tableName: string;
-    model: BaseModelBuilder<Model>;
-    fields: HasuraGraphQLFields<Model>;
-    endpoint: string;
-    authOptions: HasuraGraphQLAuthOptions;
-    logger: DebugHelper;
-    cache?: CacheConfig;
-    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>;
-    getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-    convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): Model;
-    convertDataToHasura(instance: Model, update?: boolean): Record<string, string | number>;
-};

package/src/infra/hasura-graphql/types/hasura-graphql-auth-options.type.d.ts

@@ -1,8 +0,0 @@
-export type HasuraGraphQLAuthOptions = {
-    adminSecret?: string;
-    authRole?: {
-        role: string;
-        userId: string;
-    };
-    authToken?: string;
-};

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

@@ -1,44 +0,0 @@
-import { ModelBaseStructure, NestedRepositoryFindFieltersOptions, NonFunctionAndIdentifierPropertyNames, RepositoryFindField } from '../../../domain';
-import { PropType } from '../../../utils';
-import { HasuraGraphQLColumnType } from '../enums';
-export type ColumnOptions<FieldType, Model, ValueFrom = any> = {
-    type?: HasuraGraphQLColumnType;
-    columnName?: string;
-    filters?: {
-        filterType: HasuraGraphQLColumnType | string;
-        filters: NestedRepositoryFindFieltersOptions<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;
-    bindFindFilter?: (sentence: RepositoryFindField<Model, keyof Model>) => Record<string, RepositoryFindField<any, any> | ValueFrom> | RepositoryFindField<any, any> | ValueFrom;
-    bindPersistData?: (value: FieldType, instance?: Model) => Record<string, ValueFrom>;
-};
-export type AggregateOptionNames = 'avg' | 'count' | 'max' | 'min' | 'stddev' | 'stddev_pop' | 'stddev_samp' | 'sum' | 'var_pop' | 'var_samp' | 'variance';
-export type AggregateOptionFields<Model, Type, Properties extends keyof Model = keyof Model> = {
-    [K in Properties]: PropType<Model, K> extends Type ? K : never;
-}[Properties] | string;
-export type AggregateOptions<Model> = {
-    avg?: Array<AggregateOptionFields<Model, number>>;
-    max?: Array<AggregateOptionFields<Model, number | Date>>;
-    min?: Array<AggregateOptionFields<Model, number | Date>>;
-    stddev?: Array<AggregateOptionFields<Model, number>>;
-    stddev_pop?: Array<AggregateOptionFields<Model, number>>;
-    stddev_samp?: Array<AggregateOptionFields<Model, number>>;
-    sum?: Array<AggregateOptionFields<Model, number>>;
-    var_pop?: Array<AggregateOptionFields<Model, number>>;
-    var_samp?: Array<AggregateOptionFields<Model, number>>;
-    variance?: Array<AggregateOptionFields<Model, number>>;
-};
-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;
-export type HasuraGraphQLFields<Model> = (ModelBaseHasuraGraphQLFields<Model> | {
-    aggregate: Array<AggregateOptions<Model> | 'count'>;
-} | {
-    returning: NonFunctionAndIdentifierPropertyNames<Model>[];
-} | 'affected_rows')[];
-export {};

package/src/infra/hasura-graphql/types/hasura-graphql-headers.type.d.ts

@@ -1,7 +0,0 @@
-export type HasuraGraphQLHeaders = {
-    Authorization?: string;
-    'Content-Type': string;
-    'X-Hasura-Admin-Secret'?: string;
-    'X-Hasura-Role'?: string;
-    'X-Hasura-User-Id'?: string;
-};

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

@@ -1,8 +0,0 @@
-export * from './fields.type';
-export * from './graphql.repository.type';
-export * from './nested-field.type';
-export * from './query-builder-options.type';
-export * from './variable-options.type';
-export * from './hasura-graphql-auth-options.type';
-export * from './hasura-graphql-fields.type';
-export * from './hasura-graphql-headers.type';

package/src/infra/hasura-graphql/types/nested-field.type.d.ts

@@ -1,7 +0,0 @@
-import { Fields } from './fields.type';
-import { QueryBuilderOptions } from './query-builder-options.type';
-export type NestedField = {
-    operation: string;
-    variables: QueryBuilderOptions[];
-    fields: Fields;
-};

package/src/infra/hasura-graphql/types/query-builder-options.type.d.ts

@@ -1,7 +0,0 @@
-import { Fields } from './fields.type';
-import { VariableOptions } from './variable-options.type';
-export interface QueryBuilderOptions {
-    operation: string;
-    fields?: Fields;
-    variables?: VariableOptions;
-}

package/src/infra/hasura-graphql/types/variable-options.type.d.ts

@@ -1,9 +0,0 @@
-export type VariableOptions = {
-    type?: string;
-    name?: string;
-    value: any;
-    list?: boolean;
-    required?: boolean;
-} | {
-    [k: string]: any;
-};

package/src/infra/index.d.ts

@@ -1,7 +0,0 @@
-export * from './adyen';
-export * from './cache';
-export * from './elasticsearch';
-export * from './firebase';
-export * from './hasura-graphql';
-export * from './pagarme';
-export * from './vertex-ai';

package/src/infra/pagarme/adapters/index.d.ts

@@ -1,3 +0,0 @@
-export * from './pagarme-bank-slip-payment-axios.adapter';
-export * from './pagarme-card-payment-axios.adapter';
-export * from './pagarme-pix-payment-axios.adapter';

package/src/infra/pagarme/adapters/pagarme-bank-slip-payment-axios.adapter.d.ts

@@ -1,12 +0,0 @@
-import { PaymentProviderBankSlip } from '../../../domain/shopping/interfaces';
-import { Checkout, Payment, PaymentTransaction } from '../../../domain/shopping/models';
-import { PaymentRepository } from '../../../domain/shopping/repositories';
-import { PagarmeCredentials } from '../../../domain/shopping/types';
-export declare class PagarmeBankSlipAxiosAdapter implements PaymentProviderBankSlip {
-    private credentials;
-    private paymentRepository;
-    constructor(credentials: PagarmeCredentials, paymentRepository: PaymentRepository);
-    pay(checkout: Checkout): Promise<Payment>;
-    getBoletoTransaction(paymentId: number): Promise<PaymentTransaction>;
-    private createBoletoPayment;
-}

package/src/infra/pagarme/adapters/pagarme-card-payment-axios.adapter.d.ts

@@ -1,17 +0,0 @@
-import { BusinessUnitEnum } from '../../../domain/shopping/enums';
-import { PaymentProviderCard } from '../../../domain/shopping/interfaces';
-import { Checkout, Payment, PaymentTransaction } from '../../../domain/shopping/models';
-import { OrderBlockedRepository, PaymentRepository } from '../../../domain/shopping/repositories';
-import { CardInfo, PagarMeCard, PagarmeCredentials, PaymentCardInfo } from '../../../domain/shopping/types';
-export declare class PagarmeCardAxiosAdapter implements PaymentProviderCard<PagarMeCard> {
-    private credentials;
-    private paymentRepository;
-    private orderBlockedRepository;
-    constructor(credentials: PagarmeCredentials, paymentRepository: PaymentRepository, orderBlockedRepository: OrderBlockedRepository);
-    pay(checkout: Checkout, card: PaymentCardInfo): Promise<Payment>;
-    addCard(card: CardInfo): Promise<PagarMeCard>;
-    createCardHash<PagarMeCardManualHash>(bu: BusinessUnitEnum): Promise<PagarMeCardManualHash>;
-    getCardByToken(id: string): Promise<PagarMeCard>;
-    createTransaction(info: any): Promise<PaymentTransaction>;
-    private createCardPayment;
-}

package/src/infra/pagarme/adapters/pagarme-pix-payment-axios.adapter.d.ts

@@ -1,11 +0,0 @@
-import { PaymentProviderPix } from '../../../domain/shopping/interfaces';
-import { Checkout, Payment } from '../../../domain/shopping/models';
-import { PaymentRepository } from '../../../domain/shopping/repositories';
-import { PagarmeCredentials } from '../../../domain/shopping/types';
-export declare class PagarmePixAxiosAdapter implements PaymentProviderPix {
-    private credentials;
-    private paymentRepository;
-    constructor(credentials: PagarmeCredentials, paymentRepository: PaymentRepository);
-    pay(checkout: Checkout): Promise<Payment>;
-    private createPixPayment;
-}

package/src/infra/pagarme/index.d.ts

@@ -1 +0,0 @@
-export * from './adapters';

package/src/infra/vertex-ai/adapters/index.d.ts

@@ -1,2 +0,0 @@
-export * from './vertex-ai-search.adapter';
-export * from './vertex-axios.adapter';

package/src/infra/vertex-ai/adapters/vertex-ai-search.adapter.d.ts

@@ -1,10 +0,0 @@
-import { Product } from '../../../domain';
-import { ProductBulk } from '../types';
-export interface VertexSearchAdapter<T> {
-    query(searchTerm: string, total: number, gender?: String): Promise<T[]>;
-    get(id: string): Promise<T>;
-    save(data: Product): Promise<any>;
-    update(id: string, data: Product): Promise<any>;
-    delete(id: string): Promise<void>;
-    bulkProducts(products: ProductBulk[]): Promise<void>;
-}

package/src/infra/vertex-ai/adapters/vertex-axios.adapter.d.ts

@@ -1,15 +0,0 @@
-import { Product } from '../../../domain';
-import { ProductBulk, ProductSearch } from '../types';
-import { VertexSearchConfig } from '../types/axios-vertex-search-config';
-import { VertexSearchAdapter } from './vertex-ai-search.adapter';
-export declare class VertexAxiosAdapter implements VertexSearchAdapter<ProductSearch> {
-    private readonly config;
-    private logger;
-    constructor(config: VertexSearchConfig);
-    query(term: string, total: number, gender?: String): Promise<ProductSearch[]>;
-    get(id: string): Promise<ProductSearch>;
-    save(data: Product): Promise<any>;
-    update(id: string, data: Product): Promise<any>;
-    delete(id: string): Promise<void>;
-    bulkProducts(products: ProductBulk[]): Promise<void>;
-}

package/src/infra/vertex-ai/index.d.ts

@@ -1,3 +0,0 @@
-export * from './adapters';
-export * from './indexes';
-export * from './types';

package/src/infra/vertex-ai/indexes/index.d.ts

@@ -1 +0,0 @@
-export * from './products-vertex-search';

package/src/infra/vertex-ai/indexes/products-vertex-search.d.ts

@@ -1,13 +0,0 @@
-import { ProductSearchIndex } from '../../../domain';
-import { ProductHasuraGraphQL } from '../../hasura-graphql';
-import { VertexSearchAdapter } from '../adapters';
-import { ProductSearch } from '../types';
-export declare class ProductsVertexSearch implements ProductSearchIndex {
-    private readonly adapter;
-    constructor(adapter: VertexSearchAdapter<ProductSearch>);
-    getById(id: string): Promise<ProductSearch>;
-    search<ProductSearch>(searchTerm: string, total: number, gender?: String): Promise<ProductSearch[]>;
-    save(product: ProductHasuraGraphQL): Promise<void>;
-    update(product: ProductHasuraGraphQL): Promise<void>;
-    delete(id: string): Promise<void>;
-}

package/src/infra/vertex-ai/types/axios-vertex-search-config.d.ts

@@ -1,4 +0,0 @@
-export type VertexSearchConfig = {
-    url: string;
-    token?: string;
-};