@infrab4a/connect 3.15.0 → 4.0.0-beta.0

package/domain/catalog/index.d.ts

@@ -1,3 +1,2 @@
-export * from './helpers';
 export * from './models';
 export * from './repositories';

package/domain/catalog/models/category.d.ts

@@ -1,7 +1,24 @@
-import { GenericIdentifier } from '../../generic/model';
-import { CategoryBase } from './category-base';
-import { ProductForCategory } from './product-for-category';
-export declare class Category extends CategoryBase<Category, GenericIdentifier> {
-    childrenProducts?: ProductForCategory[];
+import { BaseModel, GenericIdentifier, NonFunctionPropertyNames } from '../../generic/model';
+import { Shops } from './enums';
+import { CategoryCondition, CategoryFilter, CategoryMetadata } from './types';
+export declare class Category extends BaseModel<Category> {
+    id: string;
+    brandCategory: boolean;
+    brandLogo?: string;
+    name: string;
+    slug: string;
+    image?: string;
+    brandCategoryBanner?: string;
+    brandCategoryBannerMobile?: string;
+    description: string;
+    conditions?: CategoryCondition;
+    products?: string[];
+    filters?: CategoryFilter[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    shop: Shops;
+    published: boolean;
+    metadata: CategoryMetadata;
+    identifierFields(): NonFunctionPropertyNames<Category>[];
     static get identifiersFields(): GenericIdentifier[];
 }

package/domain/catalog/models/index.d.ts

@@ -1,11 +1,6 @@
 export * from './category';
-export * from './category-collection-children';
-export * from './category-filter';
 export * from './enums';
-export * from './filter';
-export * from './filter-option';
 export * from './kit-product';
 export * from './product';
 export * from './types';
 export * from './variant';
-export * from './wishlist';

package/domain/catalog/models/kit-product.d.ts

@@ -1,12 +1,12 @@
 import { BaseModel } from '../../generic/model';
-import { ProductForKit } from './product-for-kit';
-declare type KitProductIdentifiers = 'productId' | 'kitProductId';
+import { Product } from './product';
+declare type KitProductIdentifiers = 'productId' | 'kitProducId';
 export declare class KitProduct extends BaseModel<KitProduct, KitProductIdentifiers> {
     productId: string;
     kitProductId: string;
     quantity: number;
-    kit: ProductForKit;
-    product: ProductForKit;
+    kit: Product;
+    product: Product;
     static get identifiersFields(): KitProductIdentifiers[];
 }
 export {};

package/domain/catalog/models/product.d.ts

@@ -1,9 +1,39 @@
-import { GenericIdentifier } from '../../generic/model';
-import { CategoryForProduct } from './category-for-product';
+import { BaseModel, GenericIdentifier, NonFunctionPropertyNames } from '../../generic/model';
 import { KitProduct } from './kit-product';
-import { ProductBase } from './product-base';
-export declare class Product extends ProductBase<Product, GenericIdentifier> {
-    category: CategoryForProduct;
+import { ProductGender, ProductMetadata, ProductReview, ShopDescription, ShopPrice, Stock } from './types';
+import { Variant } from './variant';
+export declare class Product extends BaseModel<Product> {
+    id: string;
+    name: string;
+    slug: string;
+    description: ShopDescription;
+    sku: string;
+    price: ShopPrice;
+    hasVariants: boolean;
+    NCM: string;
+    EAN: string;
+    CEST: string;
+    weight: number;
+    stock: Stock;
+    costPrice: number;
+    images?: string[];
+    miniatures?: string[];
+    published: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    brand: string;
+    tags?: string[];
+    type?: string;
+    categories?: string[];
+    reviews?: ProductReview[];
+    variant?: Variant;
+    video?: string;
+    isKit?: boolean;
+    rate?: number;
+    gender?: ProductGender;
+    shoppingCount?: number;
+    metadata: ProductMetadata;
     kitProducts?: KitProduct[];
+    identifierFields(): NonFunctionPropertyNames<Product>[];
     static get identifiersFields(): GenericIdentifier[];
 }

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

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

package/domain/catalog/models/types/index.d.ts

@@ -1,7 +1,6 @@
 export * from './category-condition.type';
+export * from './category-filter.type';
 export * from './category-metadata.type';
-export * from './category-product';
-export * from './product-evaluation.type';
 export * from './product-gender.type';
 export * from './product-metadata.type';
 export * from './product-review.type';

package/domain/catalog/models/types/shop-description.type.d.ts

@@ -4,5 +4,4 @@ export declare type ShopDescription = {
     whoMustUse?: string;
     howToUse?: string;
     brand?: string;
-    ingredients?: string;
 };

package/domain/catalog/models/variant.d.ts

@@ -1,4 +1,4 @@
-import { BaseModel } from '../../generic/model';
+import { BaseModel, NonFunctionPropertyNames } from '../../generic/model';
 import { ShopPrice, Stock, VariantGrade } from './types';
 export declare type ProductVariantIdentifiers = 'id' | 'productId';
 export declare class Variant extends BaseModel<Variant, ProductVariantIdentifiers> {
@@ -13,5 +13,6 @@ export declare class Variant extends BaseModel<Variant, ProductVariantIdentifier
     weight: number;
     createdAt?: Date;
     updatedAt?: Date;
+    identifierFields(): NonFunctionPropertyNames<Variant>[];
     static get identifiersFields(): ProductVariantIdentifiers[];
 }

package/domain/catalog/repositories/category.repository.d.ts

@@ -1,11 +1,10 @@
-import { CrudRepository } from '../../generic/repository/crud.repository';
-import { Product } from '../models';
 import { Category } from '../models/category';
+import { CrudRepository } from '../../generic/repository/crud.repository';
 import { Shops } from '../models/enums/shops.enum';
+import { Product } from '../models';
 export interface CategoryRepository extends CrudRepository<Category> {
     getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
-    getCategoryByShop(shop: string): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): Promise<{
+    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
         category: Category;
         products: Product[];
     }[]>;
@@ -13,6 +12,4 @@ export interface CategoryRepository extends CrudRepository<Category> {
         limit?: number;
         hasStock?: boolean;
     }): Promise<Product[]>;
-    getChildren(parentId: number): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
 }

package/domain/catalog/repositories/index.d.ts

@@ -1,9 +1,4 @@
-export * from './category-collection-children.repository';
-export * from './category-filter.repository';
 export * from './category.repository';
-export * from './filter-option.repository';
-export * from './filter.repository';
 export * from './product.repository';
 export * from './subscription-product.repository';
 export * from './variant.repository';
-export * from './wishlist.repository';

package/domain/catalog/repositories/product.repository.d.ts

@@ -1,6 +1,5 @@
-import { FindRepositoryParams, RepositoryFindResult } from '../../generic';
 import { CrudRepository } from '../../generic/repository/crud.repository';
-import { Product, ProductGender, ProductReview } from '../models';
+import { Product, ProductReview } from '../models';
 export declare type ReviewStatusParams = 'pending' | 'approved' | 'rejected';
 export declare type ReviewWithProductData = ProductReview & {
     productId: string;
@@ -10,6 +9,4 @@ export declare type ReviewWithProductData = ProductReview & {
 export interface ProductRepository extends CrudRepository<Product> {
     getBySlug(slug: string): Promise<Product>;
     fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
-    cleanShoppingCountFromIds(ids: string[]): Promise<any>;
-    findCatalog(params: FindRepositoryParams<Product>, mainGender?: Extract<ProductGender, 'female' | 'male'>): Promise<RepositoryFindResult<Product>>;
 }

package/domain/generic/model/base.model.d.ts

@@ -1,14 +1,10 @@
-import { ModelBaseStructure, NonFunctionAndIdentifierProperties, NonFunctionAndIdentifierPropertyNames } from './types';
-export declare type GenericIdentifier<M = {
-    id: string;
-}, T = NonFunctionAndIdentifierPropertyNames<M>> = T;
-export declare class BaseModel<Model extends ModelBaseStructure<Model, Identifiers>, Identifiers = GenericIdentifier> implements ModelBaseStructure<Model, Identifiers> {
-    get identifier(): {
-        [key in Extract<NonFunctionAndIdentifierPropertyNames<Model>, Identifiers>]: Model[key];
-    };
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, NonFunctionProperties } from './types';
+export declare type GenericIdentifier<T = 'id'> = T;
+export declare class BaseModel<Model, Identifiers = GenericIdentifier> implements ModelBaseStructure<Model, Identifiers> {
+    get identifier(): NonFunctionAndIdentifierProperties<Model>;
     get identifiersFields(): Identifiers[];
     constructor(args?: Partial<Model>);
-    static toInstance<T>(this: new () => T, data?: Partial<NonFunctionAndIdentifierProperties<T>>): T;
+    static toInstance<T extends ModelBaseStructure>(this: new () => T, data?: Partial<NonFunctionProperties<T>>): T;
     static isModel<T extends ModelBaseStructure>(this: new () => T, value: any): value is T;
     toPlain(): any;
 }

package/domain/generic/model/types/base-model-builder.type.d.ts

@@ -1,8 +1,6 @@
-import { PartialIdentifiersModel } from './identifier-model.type';
-import { ModelBaseStructure } from './model-base-structure.type';
 import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
 import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
-export interface BaseModelBuilder<T extends ModelBaseStructure<T>, Identifiers = NonFunctionAndIdentifierPropertyNames<T> | any, P extends T & {
+export interface BaseModelBuilder<T, Identifiers = NonFunctionAndIdentifierPropertyNames<T>, P extends T & {
     prototype: unknown;
 } = T & {
     prototype: unknown;
@@ -12,6 +10,6 @@ export interface BaseModelBuilder<T extends ModelBaseStructure<T>, Identifiers =
     prototype: {
         [key in keyof P['prototype']]: P['prototype'][key];
     };
-    toInstance<E>(this: new () => E, data?: NonFunctionAndIdentifierPropertiesWithNoPartial<T> | PartialIdentifiersModel<T>): E;
+    toInstance(this: new () => T, data?: Partial<NonFunctionAndIdentifierPropertiesWithNoPartial<T>>): T;
     isModel(model: any): model is T;
 }

package/domain/generic/model/types/identifier-model.type.d.ts

@@ -1,8 +1,7 @@
-import { PropType } from '../../../../utils';
+import { ArrayElement, PropType } from '../../../../utils';
 import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
 import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
-export declare type IdentifierModel<Model extends ModelBaseStructure> = Extract<NonFunctionAndIdentifierPropertyNames<Model>, PropType<Model, 'identifiersFields'>[number]>;
-export declare type IdentifiersModel<Model extends ModelBaseStructure> = {
-    [K in IdentifierModel<Model>]: Model[K];
-};
-export declare type PartialIdentifiersModel<Model extends ModelBaseStructure> = Partial<IdentifiersModel<Model>>;
+export declare type IdentifierModel<Model extends ModelBaseStructure> = ArrayElement<PropType<Model, 'identifiersFields'>>;
+export declare type IdentifiersModel<Model extends ModelBaseStructure> = Pick<NonFunctionAndIdentifierPropertiesWithNoPartial<Model>, Extract<NonFunctionAndIdentifierPropertyNames<Model>, IdentifierModel<Model>>>;
+export declare type PartialIdentifiersModel<Model extends ModelBaseStructure> = Partial<Pick<NonFunctionAndIdentifierPropertiesWithNoPartial<Model>, Extract<NonFunctionAndIdentifierPropertyNames<Model>, IdentifierModel<Model>>>>;

package/domain/generic/model/types/model-base-structure.type.d.ts

@@ -1,12 +1,6 @@
-import { NonFunctionAndIdentifierPropertyNames } from '..';
-declare type ModelBaseStructureRecord = Record<string, any> & {
-    identifiersFields: any[];
-};
-export declare type ModelBaseStructure<M extends ModelBaseStructureRecord = ModelBaseStructureRecord, I = M['identifiersFields'][number]> = {
-    identifier: {
-        [key in Extract<NonFunctionAndIdentifierPropertyNames<M>, I>]: M[key];
-    };
+import { NonFunctionAndIdentifierProperties } from './non-function-properties.type';
+export declare type ModelBaseStructure<M = any, I = any> = {
+    identifier: NonFunctionAndIdentifierProperties<M>;
     identifiersFields: I[];
     toPlain: any;
 };
-export {};

package/domain/generic/model/types/non-function-property-name.type.d.ts

@@ -1,13 +1,4 @@
-export declare type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
-export declare type ReadonlyKeys<T> = {
-    [P in keyof T]-?: IfEquals<{
-        [Q in P]: T[P];
-    }, {
-        -readonly [Q in P]: T[P];
-    }, never, P>;
-}[keyof T];
-export declare type WritableKeys<T> = Exclude<keyof T, ReadonlyKeys<T>>;
-export declare type NonFunctionPropertyNames<T, P = T, E extends WritableKeys<P> = WritableKeys<P>> = {
-    [K in E]: P[K] extends Function ? never : K extends 'identifiersFields' ? never : K;
+export declare type NonFunctionPropertyNames<T, E extends keyof T = keyof T> = {
+    [K in E]: T[K] extends Function ? never : K;
 }[E];
-export declare type NonFunctionAndIdentifierPropertyNames<T> = NonFunctionPropertyNames<Omit<T, 'identifier' | 'identifiersFields'>>;
+export declare type NonFunctionAndIdentifierPropertyNames<T> = NonFunctionPropertyNames<T, Exclude<keyof T, 'identifier' | 'identifiersFields'>>;

package/domain/generic/repository/create.repository.d.ts

@@ -1,7 +1,7 @@
 import { PropType } from '../../../utils';
-import { ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoIdentifiers, PartialIdentifiersModel } from '../model/types';
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, PartialIdentifiersModel } from '../model/types';
 export declare type CreateRepositoryParams<Model extends ModelBaseStructure> = {
-    [key in keyof NonFunctionAndIdentifierPropertiesWithNoIdentifiers<Model>]: PropType<Model, key> extends ModelBaseStructure ? CreateRepositoryParams<PropType<Model, key>> : PropType<Model, key>;
+    [key in keyof NonFunctionAndIdentifierProperties<Model>]: PropType<Model, key> extends ModelBaseStructure ? CreateRepositoryParams<PropType<Model, key>> : PropType<Model, key>;
 } & PartialIdentifiersModel<Model>;
 export interface CreateRepository<Model extends ModelBaseStructure, Params = CreateRepositoryParams<Model>> {
     create(data: Params): Promise<Model>;

package/domain/generic/repository/find.repository.d.ts

@@ -1,16 +1,10 @@
-import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from '../model/types';
+import { ModelBaseStructure, NonFunctionPropertyNames } from '../model/types';
 import { RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from './types';
 export declare type FindRepositoryParams<Model extends ModelBaseStructure> = {
     filters?: RepositoryFindFielters<Model>;
     fields?: NonFunctionPropertyNames<Model>[];
     limits?: RepositoryLimitOptions<Model>;
     orderBy?: RepositoryOrderBy<Model>;
-    options?: {
-        enableCount?: boolean;
-        minimal?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
-        maximum?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
-        distinct?: Array<NonFunctionAndIdentifierPropertyNames<Model> | {}>;
-    };
 };
 export interface FindRepository<Model extends ModelBaseStructure, Params = FindRepositoryParams<Model>> {
     find(options?: Params): Promise<RepositoryFindResult<Model>>;

package/domain/generic/repository/get.repository.d.ts

@@ -1,5 +1,5 @@
-import { IdentifiersModel, ModelBaseStructure } from '../model/types';
-export declare type GetRepositoryParams<Model extends ModelBaseStructure> = IdentifiersModel<Model>;
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties } from '../model/types';
+export declare type GetRepositoryParams<Model extends ModelBaseStructure> = NonFunctionAndIdentifierProperties<Model>;
 export interface GetRepository<Model extends ModelBaseStructure, Params = GetRepositoryParams<Model>> {
     get(identifiers: Params): Promise<Model>;
 }

package/domain/generic/repository/types/repository-find-filters.type.d.ts

@@ -1,6 +1,6 @@
 import { PropType } from '../../../../utils';
 import { ModelBaseStructure } from '../../model';
-import { NonFunctionAndIdentifierPropertyNames } from '../../model/types/non-function-property-name.type';
+import { NonFunctionPropertyNames } from '../../model/types/non-function-property-name.type';
 import { Where } from '../enums/where.enum';
 export declare type RepositoryFindFieltersOptions<Model, FieldName extends keyof Model> = {
     operator: Where;
@@ -8,6 +8,6 @@ export declare type RepositoryFindFieltersOptions<Model, FieldName extends keyof
 };
 export declare type RepositoryFindField<Model, FieldName extends keyof Model> = RepositoryFindFieltersOptions<Model, FieldName> | RepositoryFindFieltersOptions<Model, FieldName>[] | Partial<PropType<Model, FieldName>>;
 export declare type NestedRepositoryFindFieltersOptions<Model> = {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Model, key>> : PropType<Required<Model>, key> extends any[] ? PropType<Required<Model>, key>[number] extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : PropType<Required<Model>, key>[number] extends Record<string, any> ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : RepositoryFindField<Model, key> : PropType<Model, key> extends Record<string, any> ? NestedRepositoryFindFieltersOptions<Required<PropType<Model, key>>> : RepositoryFindField<Model, key>;
+    [key in NonFunctionPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure<PropType<Model, key>> ? NestedRepositoryFindFieltersOptions<PropType<Model, key>> : PropType<Required<Model>, key> extends any[] ? PropType<Required<Model>, key>[number] extends ModelBaseStructure ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : PropType<Required<Model>, key>[number] extends Record<string, any> ? NestedRepositoryFindFieltersOptions<PropType<Required<Model>, key>[number]> : RepositoryFindField<Model, key> : PropType<Model, key> extends Record<string, any> ? NestedRepositoryFindFieltersOptions<Required<PropType<Model, key>>> : RepositoryFindField<Model, key>;
 };
-export declare type RepositoryFindFielters<Model extends ModelBaseStructure> = NestedRepositoryFindFieltersOptions<Model>;
+export declare type RepositoryFindFielters<Model extends ModelBaseStructure<Model>> = NestedRepositoryFindFieltersOptions<Model>;

package/domain/generic/repository/types/repository-find-result.type.d.ts

@@ -1,14 +1,4 @@
-import { NonFunctionAndIdentifierPropertyNames } from '../../model';
-declare type SortableFields<Model> = {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]: Model[key];
-} & Record<string, any>;
 export declare type RepositoryFindResult<Model> = {
     data: Model[];
-    count?: number;
-    minimal?: SortableFields<Model>;
-    maximum?: SortableFields<Model>;
-    distinct?: {
-        [key in NonFunctionAndIdentifierPropertyNames<Model>]: Model[key] extends string ? Model[key][] : Model[key] extends number ? Model[key][] : Model[key] extends boolean ? Model[key][] : Model[key] extends Date ? Model[key][] : never;
-    };
+    count: number;
 };
-export {};

package/domain/generic/repository/types/repository-order-by-list.type.d.ts

@@ -1,5 +1,5 @@
-import { NonFunctionAndIdentifierPropertyNames } from '../../model/types/non-function-property-name.type';
+import { NonFunctionPropertyNames } from '../../model/types/non-function-property-name.type';
 export declare type RepositoryOrderBy<Model> = {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: 'asc' | 'desc';
+    [key in NonFunctionPropertyNames<Model>]?: 'asc' | 'desc';
 };
 export declare type RepositoryOrderByList<Model> = RepositoryOrderBy<Model>[];

package/domain/generic/repository/types/repository-update-params.type.d.ts

@@ -1,11 +1,11 @@
 import { ModelBaseStructure } from '../..';
 import { PropType } from '../../../../utils';
-import { NonFunctionAndIdentifierPropertyNames } from '../../model/types/non-function-property-name.type';
+import { NonFunctionPropertyNames } from '../../model/types/non-function-property-name.type';
 export declare type UpdateOptionAction = 'removeField' | 'update' | 'merge' | 'remove' | 'null';
 export declare type UpdateOptions<T> = {
     action: UpdateOptionAction;
     value?: T;
 };
 export declare type RepositoryUpdateParams<Model extends ModelBaseStructure> = {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: UpdateOptions<PropType<Model, key>> | PropType<Model, key>;
+    [key in NonFunctionPropertyNames<Model>]?: UpdateOptions<PropType<Model, key>> | PropType<Model, key>;
 };

package/domain/location/models/address.d.ts

@@ -1,14 +1,12 @@
-import { BaseModel, GenericIdentifier, ModelBaseStructure } from '../../generic';
+import { BaseModel, GenericIdentifier } from '../../generic/model/base.model';
 import { LocationGeometry } from './types/location-geometry.type';
-export declare abstract class Address<ChildAddress extends ModelBaseStructure<ChildAddress, Identifiers>, Identifiers = ChildAddress['identifiersFields']> extends BaseModel<ChildAddress, Identifiers> {
-    id: string;
+export declare abstract class Address<Identifiers = GenericIdentifier> extends BaseModel<Address, Identifiers> {
     default?: boolean;
     recipient?: string;
     zip?: string;
     street?: string;
     number?: string;
     extension?: string;
-    reference?: string;
     district?: string;
     city?: string;
     regionalPole?: string;
@@ -20,5 +18,5 @@ export declare abstract class Address<ChildAddress extends ModelBaseStructure<Ch
     formattedAddress?: string;
     placeId?: string;
     geometry?: LocationGeometry;
-    static get identifiersFields(): Array<GenericIdentifier | {}>;
+    static get identifiersFields(): string[];
 }

package/domain/shop-settings/models/index.d.ts

@@ -1,4 +1,3 @@
 export * from './home';
 export * from './shop-menu';
-export * from './shop-settings';
 export * from './types';

package/domain/shop-settings/models/types/index.d.ts

@@ -1,10 +1,5 @@
 export * from './banner.type';
 export * from './benefit.type';
-export * from './home-data.type';
 export * from './menu-nav.type';
-export * from './shop-banner.type';
-export * from './shop-brands.type';
-export * from './shop-carousel.type';
-export * from './shop-collection.type';
-export * from './shop-section.type';
 export * from './sub-menu.type';
+export * from './home-data.type';

package/domain/shop-settings/repositories/index.d.ts

@@ -1,3 +1,2 @@
 export * from './home.repository';
 export * from './shop-menu.repository';
-export * from './shop-settings.repository';

package/domain/shopping/models/buy-2-win.d.ts

@@ -1,5 +1,5 @@
-import { Category, Shops } from '../../catalog/models';
 import { BaseModel, GenericIdentifier } from '../../generic/model/base.model';
+import { Shops, Category } from '../../catalog/models';
 export declare class Buy2Win extends BaseModel<Buy2Win> {
     active: boolean;
     cartValue: number;
@@ -9,8 +9,6 @@ export declare class Buy2Win extends BaseModel<Buy2Win> {
     name: string;
     products?: string[];
     shop: Shops;
-    activeCategory?: boolean;
-    cartValueMin?: number;
     startDate: Date;
     updatedAt?: Date;
     categories: Category[];

package/domain/shopping/models/checkout.d.ts

@@ -1,13 +1,14 @@
-import { Shops } from '../../catalog/models/enums/shops.enum';
+import { Address } from '../../location/models/address';
 import { BaseModel, GenericIdentifier } from '../../generic/model/base.model';
-import { User, UserAddress } from '../../users';
+import { User } from '../../users/models/user';
 import { Coupon } from './coupons/coupon';
 import { LineItem } from './line-item';
 import { ShippingMethod } from './shipping-method';
+import { Shops } from '../../catalog/models/enums/shops.enum';
 export declare class Checkout extends BaseModel<Checkout> {
     id?: string;
     paymentId?: string;
-    status?: any;
+    status?: string;
     createdAt?: Date;
     updatedAt?: Date;
     completedAt?: Date;
@@ -18,8 +19,8 @@ export declare class Checkout extends BaseModel<Checkout> {
     glampoints?: number;
     lineItems?: LineItem[];
     user?: User;
-    shippingAddress?: UserAddress;
-    billingAddress?: UserAddress;
+    shippingAddress?: Address;
+    billingAddress?: Address;
     shipping?: ShippingMethod;
     coupon?: Coupon;
     static get identifiersFields(): GenericIdentifier[];

package/domain/shopping/models/coupons/coupon.d.ts

@@ -5,44 +5,16 @@ import { CouponTypes, Exclusivities } from './enums';
 import { ClubeDaMensPlan } from './enums/coupon-club-mens.enum';
 export declare class Coupon extends BaseModel<Coupon> {
     id: string;
-    category?: string;
-    discount: {
-        subscriber: {
-            type: CouponTypes;
-            value: number;
-        };
-        non_subscriber: {
-            type: CouponTypes;
-            value: number;
-        };
-        subscription?: {
-            type: CouponTypes;
-            value: number;
-        };
-    };
-    useLimits: {
-        subscriber: {
-            unlimited?: boolean;
-            total?: number;
-            limitedPerUser?: boolean;
-        };
-        non_subscriber: {
-            unlimited?: boolean;
-            total?: number;
-            limitedPerUser?: boolean;
-        };
-        subscription?: {
-            unlimited?: boolean;
-            total?: number;
-            limitedPerUser?: boolean;
-        };
-    };
+    type: CouponTypes;
+    discount?: number;
     user?: string;
-    userExclusiveEmail?: string[];
+    userExclusiveEmail?: string;
     campaign?: string;
     nickname: string;
     beginAt: Date;
     expiresIn?: Date;
+    useLimit?: number;
+    useLimitPerUser?: boolean;
     shopAvailability: Shops;
     personId?: number;
     influencerEmail?: string;
@@ -53,7 +25,7 @@ export declare class Coupon extends BaseModel<Coupon> {
     createdAt: Date;
     updatedAt?: Date;
     checkoutType: CheckoutTypes;
-    exclusivityType?: [Exclusivities];
+    exclusivityType?: Exclusivities;
     get isInfluencer(): boolean;
     static get identifiersFields(): GenericIdentifier[];
     static createCoupon(userId: string): Coupon;

package/domain/shopping/models/index.d.ts

@@ -1,12 +1,11 @@
-export * from './buy-2-win';
-export * from './campaign-dashboard';
-export * from './campaign-hashtag';
-export * from './checkout';
 export * from './coupons';
 export * from './enums';
+export * from './types';
+export * from './checkout';
 export * from './line-item';
 export * from './order';
 export * from './payment';
 export * from './shipping-method';
 export * from './subscription';
-export * from './types';
+export * from './buy-2-win';
+export * from './buy-2-win';

package/domain/shopping/models/order.d.ts

@@ -2,7 +2,6 @@ import { Checkout } from './checkout';
 import { OrderStatus } from './enums/order-status.enum';
 import { Payment } from './payment';
 export declare class Order extends Checkout {
-    orderNumber?: string;
     status: OrderStatus;
     trackingCode?: string;
     trackingUrl?: string;

package/domain/shopping/models/shipping-method.d.ts

@@ -12,6 +12,5 @@ export declare class ShippingMethod extends BaseModel<ShippingMethod> {
     State: string;
     ZipEnd: number;
     ZipStart: number;
-    invoiceNumber?: string;
     static get identifiersFields(): GenericIdentifier[];
 }

package/domain/shopping/models/subscription/checkout.d.ts

@@ -1,6 +1,7 @@
+import { Address } from '../../../location/models/address';
 import { BaseModel, GenericIdentifier } from '../../../generic/model/base.model';
-import { User, UserAddress } from '../../../users';
 import { Coupon } from '../coupons/coupon';
+import { User } from '../../../users/models/user';
 import { SubscriptionPlan } from './plan';
 export declare class CheckoutSubscription extends BaseModel<CheckoutSubscription> {
     id?: string;
@@ -12,8 +13,8 @@ export declare class CheckoutSubscription extends BaseModel<CheckoutSubscription
     discount?: number;
     subTotalPrice?: number;
     totalPrice?: number;
-    shippingAddress: UserAddress;
-    billingAddress?: UserAddress;
+    shippingAddress: Address;
+    billingAddress?: Address;
     subscriptionPlan: SubscriptionPlan;
     coupon?: Coupon;
     static get identifiersFields(): GenericIdentifier[];

package/domain/shopping/repositories/index.d.ts

@@ -1,9 +1,7 @@
-export * from './buy-2-win.repository';
-export * from './campaign-dashboard.repository';
-export * from './campaign-hashtag.repository';
 export * from './checkout.repository';
 export * from './coupon.repository';
-export * from './legacy-order.repository';
 export * from './order.repository';
 export * from './payment.repository';
 export * from './subscription';
+export * from './buy-2-win.repository';
+export * from './legacy-order.repository';

package/domain/users/errors/unauthorized.error.d.ts

@@ -1,5 +1,4 @@
 import { CustomError } from 'ts-custom-error';
 export declare class UnauthorizedError extends CustomError {
-    readonly message: any;
-    constructor(message: any);
+    constructor(message: string);
 }