@infrab4a/connect 1.0.0-beta.1 → 1.0.0-beta.10

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

@@ -0,0 +1,23 @@
+import { BaseModel, GenericIdentifier, NonFunctionPropertyNames } from '../../generic/model';
+import { Shops } from './enums';
+import { CategoryCondition, CategoryFilter } 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;
+    identifierFields(): NonFunctionPropertyNames<Category>[];
+    static get identifiersFields(): GenericIdentifier[];
+}

package/domain/catalog/models/enums/shops.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum Shops {
+    MENSMARKET = "mensmarket",
+    GLAMSHOP = "Glamshop",
+    GLAMPOINTS = "Glampoints"
+}

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

@@ -0,0 +1,36 @@
+import { BaseModel, GenericIdentifier, NonFunctionPropertyNames } from '../../generic/model';
+import { Shops } from './enums/shops.enum';
+import { ProductReview, ShopDescription, ShopPrice, ShopsDescription, ShopsPrice, Stock } from './types';
+import { Variant } from './variant';
+export declare class Product extends BaseModel<Product> {
+    id: string;
+    name: string;
+    slug: string;
+    shopAvailability: Shops[];
+    description: ShopsDescription;
+    sku: string;
+    price: ShopsPrice;
+    hasVariants: boolean;
+    NCM: string;
+    EAN: string;
+    CEST: string;
+    weight: number;
+    stock: Stock;
+    costPrice: number;
+    images?: string[];
+    miniatures?: string[];
+    published: boolean;
+    publishedGlam: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    brand: string;
+    tags?: string[];
+    type?: string;
+    categories?: string[];
+    reviews?: ProductReview[];
+    variant?: Variant;
+    video?: string;
+    identifierFields(): NonFunctionPropertyNames<Product>[];
+    getInfoByShop(shop: Shops): ShopDescription & ShopPrice & Stock;
+    static get identifiersFields(): GenericIdentifier[];
+}

package/domain/catalog/models/types/product-review.type.d.ts

@@ -0,0 +1,15 @@
+import { Shops } from '../enums/shops.enum';
+export declare type ProductReview = {
+    author: string;
+    createdAt: Date;
+    email: string;
+    location: string;
+    rate: number;
+    review: string;
+    status: boolean;
+    title: string;
+    shop?: Shops;
+    personId?: number;
+    points?: number;
+    orderId?: string;
+};

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

@@ -0,0 +1,18 @@
+import { BaseModel, NonFunctionPropertyNames } from '../../generic/model';
+import { ShopsPrice, Stock, VariantGrade } from './types';
+export declare type ProductVariantIdentifiers = 'id' | 'productId';
+export declare class Variant extends BaseModel<Variant, ProductVariantIdentifiers> {
+    id: string;
+    productId: string;
+    sku: string;
+    price: ShopsPrice;
+    EAN: string;
+    stock: Stock;
+    grade?: VariantGrade[];
+    costPrice: number;
+    weight: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    identifierFields(): NonFunctionPropertyNames<Variant>[];
+    static get identifiersFields(): ProductVariantIdentifiers[];
+}

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

@@ -0,0 +1,15 @@
+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>;
+    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
+        category: Category;
+        products: Product[];
+    }[]>;
+    mountCategory(category: Category, options?: {
+        limit?: number;
+        hasStock?: boolean;
+    }): Promise<Product[]>;
+}

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

@@ -0,0 +1,5 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Product, Shops } from '../models';
+export interface ProductRepository extends CrudRepository<Product> {
+    getBySlug(slug: string, shop: Shops): Promise<Product>;
+}

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

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Product } from '../models';
+export interface SubscriptionProductRepository extends CrudRepository<Product> {
+}

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

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Variant } from '../models/variant';
+export interface VariantRepository extends CrudRepository<Variant> {
+}

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

@@ -0,0 +1,10 @@
+import { ModelBaseStructure, NonFunctionProperties, NonFunctionAndIdentifierProperties } 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 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/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base.model';
+export * from './identifier-fields';
+export * from './types';

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

@@ -0,0 +1,15 @@
+import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
+import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
+export interface BaseModelBuilder<T, Identifiers = NonFunctionAndIdentifierPropertyNames<T>, P extends T & {
+    prototype: unknown;
+} = T & {
+    prototype: unknown;
+}> {
+    new (...args: any[]): T;
+    identifiersFields: Identifiers[];
+    prototype: {
+        [key in keyof P['prototype']]: P['prototype'][key];
+    };
+    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

@@ -0,0 +1,7 @@
+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> = 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/index.d.ts

@@ -0,0 +1,5 @@
+export * from './non-function-property-name.type';
+export * from './non-function-properties.type';
+export * from './base-model-builder.type';
+export * from './model-base-structure.type';
+export * from './identifier-model.type';

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

@@ -0,0 +1,6 @@
+import { NonFunctionAndIdentifierProperties } from './non-function-properties.type';
+export declare type ModelBaseStructure<M = any, I = any> = {
+    identifier: NonFunctionAndIdentifierProperties<M>;
+    identifiersFields: I[];
+    toPlain: any;
+};

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

@@ -0,0 +1,12 @@
+import { PropType } from '../../../../utils';
+import { IdentifierModel, PartialIdentifiersModel } from './identifier-model.type';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from './non-function-property-name.type';
+export declare type NonFunctionProperties<T> = Pick<Partial<T>, NonFunctionPropertyNames<T>>;
+export declare type NonFunctionAndIdentifierProperties<T> = Pick<Partial<T>, NonFunctionAndIdentifierPropertyNames<T>>;
+export declare type NonFunctionAndIdentifierPropertiesWithNoPartial<T> = Pick<T, NonFunctionAndIdentifierPropertyNames<T>>;
+export declare type NonFunctionAndIdentifierPropertiesWithNoModels<T> = {
+    [key in keyof NonFunctionAndIdentifierPropertiesWithNoPartial<T>]: PropType<T, key> extends ModelBaseStructure ? NonFunctionAndIdentifierPropertiesWithNoIdentifiers<PropType<T, key>> & PartialIdentifiersModel<PropType<T, key>> : PropType<T, key> extends ModelBaseStructure[] ? PropType<T, key>[] : PropType<T, key>;
+};
+export declare type NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> = Omit<NonFunctionAndIdentifierPropertiesWithNoModels<T>, T extends ModelBaseStructure ? IdentifierModel<T> : never>;
+export declare type NonFunctionAndIdentifierPropertiesWithPartialIdentifiers<T> = NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> & (T extends ModelBaseStructure ? PartialIdentifiersModel<T> : never);

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

@@ -0,0 +1,4 @@
+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<T, Exclude<keyof T, 'identifier' | 'identifiersFields'>>;

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

@@ -0,0 +1,8 @@
+import { PropType } from '../../../utils';
+import { IdentifiersModel, ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoIdentifiers, PartialIdentifiersModel } from '../model/types';
+export declare type CreateRepositoryParams<Model extends ModelBaseStructure> = {
+    [key in keyof NonFunctionAndIdentifierPropertiesWithNoIdentifiers<Model>]: PropType<Model, key> extends ModelBaseStructure ? IdentifiersModel<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/crud.repository.d.ts

@@ -0,0 +1,19 @@
+import { ModelBaseStructure } from '../model/types/model-base-structure.type';
+import { CreateRepository, CreateRepositoryParams } from './create.repository';
+import { DeleteRepository, DeleteRepositoryParams } from './delete.repository';
+import { ReadRepository, ReadRepositoryParams } from './read.repository';
+import { UpdateRepository, UpdateRepositoryParams } from './update.repository';
+export declare type CrudGenericParams = {
+    Create?: any;
+    Delete?: any;
+    Read?: ReadRepositoryParams<any>;
+    Update?: any;
+};
+export declare type CrudParams<Model extends ModelBaseStructure> = {
+    Create?: CreateRepositoryParams<Model>;
+    Delete?: DeleteRepositoryParams<Model>;
+    Read?: ReadRepositoryParams<Model>;
+    Update?: UpdateRepositoryParams<Model>;
+};
+export interface CrudRepository<Model extends ModelBaseStructure, Params extends CrudGenericParams = CrudParams<Model>> extends CreateRepository<Model, CreateRepositoryParams<Model> & Params['Create']>, DeleteRepository<Model, DeleteRepositoryParams<Model> & Params['Delete']>, ReadRepository<Model, ReadRepositoryParams<Model> & Params['Read']>, UpdateRepository<Model, UpdateRepositoryParams<Model> & Params['Update']> {
+}

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

@@ -0,0 +1,7 @@
+import { IdentifiersModel, ModelBaseStructure } from '../model/types';
+export declare type DeleteRepositoryParams<Model extends ModelBaseStructure> = {
+    [K in keyof IdentifiersModel<Model>]: Model[K] | null;
+};
+export interface DeleteRepository<Model extends ModelBaseStructure, Params = DeleteRepositoryParams<Model>> {
+    delete(identifiers: Params): Promise<void>;
+}

package/domain/generic/repository/enums/where.enum.d.ts

@@ -0,0 +1,13 @@
+export declare enum Where {
+    EQUALS = "==",
+    GT = ">",
+    GTE = ">=",
+    IN = "in",
+    NOTIN = "not in",
+    LT = "<",
+    LTE = "<=",
+    LIKE = "like",
+    NOTLIKE = "not like",
+    ISNULL = "is null",
+    ISNOTNULL = "is not null"
+}

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

@@ -0,0 +1,10 @@
+import { ModelBaseStructure } from '../model/types/model-base-structure.type';
+import { RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from './types';
+export declare type FindRepositoryParams<Model extends ModelBaseStructure> = {
+    filters?: RepositoryFindFielters<Model>;
+    limits?: RepositoryLimitOptions<Model>;
+    orderBy?: RepositoryOrderBy<Model>;
+};
+export interface FindRepository<Model extends ModelBaseStructure, Params = FindRepositoryParams<Model>> {
+    find(options?: Params): Promise<RepositoryFindResult<Model>>;
+}

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

@@ -0,0 +1,5 @@
+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/read.repository.d.ts

@@ -0,0 +1,14 @@
+import { ModelBaseStructure } from '../model/types';
+import { FindRepository, FindRepositoryParams } from './find.repository';
+import { GetRepository, GetRepositoryParams } from './get.repository';
+declare type ReadGenericRepository = {
+    Find?: any;
+    Get?: any;
+};
+export declare type ReadRepositoryParams<Model extends ModelBaseStructure> = {
+    Find?: FindRepositoryParams<Model>;
+    Get?: GetRepositoryParams<Model>;
+};
+export interface ReadRepository<Model extends ModelBaseStructure, Params extends ReadGenericRepository = ReadRepositoryParams<Model>> extends FindRepository<Model, FindRepositoryParams<Model> & Params['Find']>, GetRepository<Model, GetRepositoryParams<Model> & Params['Get']> {
+}
+export {};

package/domain/generic/repository/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './repository-find-filters.type';
+export * from './repository-order-by-list.type';
+export * from './repository-limit-options.type';
+export * from './repository-find-result.type';
+export * from './repository-update-params.type';
+export * from './where-options.type';

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

@@ -0,0 +1,13 @@
+import { NonFunctionPropertyNames } from '../../model/types/non-function-property-name.type';
+import { PropType } from '../../../../utils';
+import { Where } from '../enums/where.enum';
+import { ModelBaseStructure } from '../../model';
+export declare type RepositoryFindFieltersOptions<Model, FieldName extends keyof Model> = {
+    operator: Where;
+    value?: PropType<Model, FieldName> | PropType<Model, FieldName>[];
+};
+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 NonFunctionPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure<PropType<Model, key>> ? NestedRepositoryFindFieltersOptions<PropType<Model, key>> : PropType<Model, key> extends any[] ? 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<Model>> = NestedRepositoryFindFieltersOptions<Model>;

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

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

package/domain/generic/repository/types/where-options.type.d.ts

@@ -0,0 +1,2 @@
+import { Where } from '../enums/where.enum';
+export declare type WhereOptions = keyof typeof Where;

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

@@ -0,0 +1,6 @@
+import { ModelBaseStructure } from '../model/types/model-base-structure.type';
+import { RepositoryUpdateParams } from './types';
+export declare type UpdateRepositoryParams<Model extends ModelBaseStructure> = RepositoryUpdateParams<Model>;
+export interface UpdateRepository<Model extends ModelBaseStructure, Params = RepositoryUpdateParams<Model>> {
+    update(data: Params): Promise<Model>;
+}

package/domain/index.d.ts

@@ -0,0 +1,6 @@
+export * from './generic';
+export * from './users';
+export * from './catalog';
+export * from './location';
+export * from './shopping';
+export * from './shop-settings';

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

@@ -0,0 +1,22 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model/base.model';
+import { LocationGeometry } from './types/location-geometry.type';
+export declare abstract class Address<Identifiers = GenericIdentifier> extends BaseModel<Address, Identifiers> {
+    default?: boolean;
+    recipient?: string;
+    zip?: string;
+    street?: string;
+    number?: string;
+    extension?: string;
+    district?: string;
+    city?: string;
+    regionalPole?: string;
+    region?: string;
+    state?: string;
+    country?: string;
+    mailbox?: boolean;
+    mailboxNumber?: string;
+    formattedAddress?: string;
+    placeId?: string;
+    geometry?: LocationGeometry;
+    static get identifiersFields(): string[];
+}

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

@@ -0,0 +1,17 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { Banner, Benefit, HomeDataStructure } from './types';
+export declare class Home extends BaseModel<Home> {
+    benefitsSection: Benefit[];
+    blockBanners: Banner[];
+    blogBanner: Banner;
+    brandsCarousel: Banner[];
+    buyToWinBanner: Banner;
+    discoverCategories: string[];
+    featuredCampaignBanner: Banner;
+    featuredCategories: string[];
+    heroCarousel: Banner[];
+    verticalCarousels: string[];
+    id: string;
+    data: HomeDataStructure;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,7 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { MenuNav } from './types/menu-nav.type';
+export declare class ShopMenu extends BaseModel<ShopMenu> {
+    menuNav: MenuNav[];
+    id: string;
+    static get identifiersFields(): GenericIdentifier[];
+}

package/domain/shop-settings/models/types/home-data.type.d.ts

@@ -0,0 +1,15 @@
+import { Category, Product } from '../../../catalog';
+export declare type HomeCategoryGroup = {
+    category: Category;
+    products: Product[];
+};
+export declare type HomeData = {
+    discoverProducts: HomeCategoryGroup[];
+    featuredProducts: HomeCategoryGroup[];
+    verticalProducts: HomeCategoryGroup[];
+};
+export declare type HomeDataStructure = {
+    createdAt: Date;
+    expiresAt: Date;
+    data: HomeData;
+};

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

@@ -0,0 +1,5 @@
+export * from './banner.type';
+export * from './benefit.type';
+export * from './menu-nav.type';
+export * from './sub-menu.type';
+export * from './home-data.type';

package/domain/shop-settings/repositories/home.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Home } from '../models/home';
+export interface HomeRepository extends CrudRepository<Home> {
+}

package/domain/shop-settings/repositories/shop-menu.repository.d.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { ShopMenu } from '../models/shop-menu';
+export interface ShopMenuRepository extends CrudRepository<ShopMenu> {
+}

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

@@ -0,0 +1,16 @@
+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;
+    createdAt: Date;
+    endDate: Date;
+    id?: string;
+    name: string;
+    products?: string[];
+    shop: Shops;
+    startDate: Date;
+    updatedAt?: Date;
+    categories: Category[];
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,27 @@
+import { Address } from '../../location/models/address';
+import { BaseModel, GenericIdentifier } from '../../generic/model/base.model';
+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?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    completedAt?: Date;
+    discount?: number;
+    subTotalPrice?: number;
+    totalPrice?: number;
+    shop: Shops;
+    glampoints?: number;
+    lineItems?: LineItem[];
+    user?: User;
+    shippingAddress?: Address;
+    billingAddress?: Address;
+    shipping?: ShippingMethod;
+    coupon?: Coupon;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,26 @@
+import { BaseModel, GenericIdentifier } from '../../../generic/model/base.model';
+import { CheckoutTypes } from '../enums/checkout-types.enum';
+import { Shops } from '../../../catalog/models/enums/shops.enum';
+import { CouponTypes, Exclusivities } from './enums';
+export declare class Coupon extends BaseModel<Coupon> {
+    id: string;
+    type: CouponTypes;
+    discount?: number;
+    user?: string;
+    recipient?: string;
+    store?: Shops;
+    campaign?: string;
+    name: string;
+    nickname: string;
+    expiresIn?: Date;
+    useLimit?: number;
+    createdAt: Date;
+    updatedAt?: Date;
+    shopAvailability: Shops;
+    personId?: number;
+    influencerEmail?: string;
+    checkoutType: CheckoutTypes;
+    exclusivityType?: Exclusivities;
+    get isInfluencer(): boolean;
+    static get identifiersFields(): GenericIdentifier[];
+}

package/domain/shopping/models/coupons/enums/coupon-subtypes.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum CouponSubtypes {
+    ABSOLUTE = 1,
+    PERCENTAGE = 2
+}

package/domain/shopping/models/coupons/enums/coupon-types.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum CouponTypes {
+    FINANCIAL = 1,
+    PRODUCT = 2,
+    GIFTCARD = 3,
+    VOUCHER = 4
+}

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

@@ -0,0 +1,3 @@
+export * from './coupon-types.enum';
+export * from './coupon-subtypes.enum';
+export * from './exclusivities.enum';

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

@@ -0,0 +1,9 @@
+import { Coupon } from './coupon';
+import { CouponTypes, CouponSubtypes } from './enums';
+export declare class FinancialCoupon extends Coupon {
+    type: CouponTypes;
+    subtype: CouponSubtypes;
+    plan?: string;
+    static isFinancialCoupon(coupon: Partial<FinancialCoupon>): coupon is FinancialCoupon;
+    static createCoupon(userId: string): FinancialCoupon;
+}

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

@@ -0,0 +1,3 @@
+export * from './enums';
+export * from './coupon';
+export * from './financial-coupon';

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

@@ -0,0 +1,67 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model/base.model';
+import { PaymentBilling, PaymentCard, PaymentCustomer, PaymentItem, PaymentShipping } from './types';
+export declare class Payment extends BaseModel<Payment> {
+    id: number;
+    object: string;
+    status: string;
+    tid: number;
+    nsu: number;
+    amount: number;
+    cost: number;
+    installments: number;
+    referer: string;
+    ip: string;
+    phone: string;
+    address: string;
+    metadata: any;
+    device: string;
+    payment: string;
+    addition: string;
+    discount: string;
+    customer: PaymentCustomer;
+    billing: PaymentBilling;
+    shipping: PaymentShipping;
+    items: PaymentItem[];
+    card: PaymentCard;
+    refuseReason: string;
+    statusReason: string;
+    acquirerResponseCode: string;
+    acquirerName: string;
+    acquirerId: string;
+    authorizationCode: string;
+    softDescriptor: string;
+    dateCreated: string;
+    dateUpdated: string;
+    authorizedAmount: number;
+    paidAmount: number;
+    refundedAmount: number;
+    cardHolderName: string;
+    cardLastDigits: string;
+    cardFirstDigits: string;
+    cardBrand: string;
+    cardPinMode: string;
+    cardMagstripeFallback: boolean;
+    cvmPin: boolean;
+    postbackUrl: string;
+    paymentMethod: string;
+    captureMethod: string;
+    antifraudScore: string;
+    boletoUrl: string;
+    boletoBarcode: string;
+    boletoExpirationDate: string;
+    subscriptionId: string;
+    splitRules: string;
+    antifraudMetadata: any;
+    referenceKey: string;
+    localTransactionId: string;
+    localTime: string;
+    fraudCovered: boolean;
+    fraudReimbursed: string;
+    orderId: string;
+    riskLevel: string;
+    receiptUrl: string;
+    privateLabel: string;
+    pixQrCode: string;
+    pixExpirationDate: string;
+    static get identifiersFields(): GenericIdentifier[];
+}