@ikas/storefront 1.0.16-alpha.1 → 1.0.16

package/build/models/theme/page/component/prop-value/brand.d.ts

@@ -0,0 +1,5 @@
+export declare class IkasBrandPropValue {
+    brandId?: string | null;
+    usePageData?: boolean | null;
+    constructor(data: Partial<IkasBrandPropValue>);
+}

package/build/models/theme/page/component/prop-value/category-list.d.ts

@@ -0,0 +1,9 @@
+import { IkasCategoryListSortType, IkasCategoryListType } from "../../../../ui/category-list/index";
+export declare class IkasCategoryListPropValue {
+    categoryListType: IkasCategoryListType;
+    initialSort?: IkasCategoryListSortType | null;
+    initialLimit?: number | null;
+    categoryCount?: number | null;
+    categoryIds?: string[] | null;
+    constructor(data: Partial<IkasCategoryListPropValue>);
+}

package/build/models/theme/page/component/prop-value/category.d.ts

@@ -0,0 +1,5 @@
+export declare class IkasCategoryPropValue {
+    categoryId?: string | null;
+    usePageData?: boolean | null;
+    constructor(data: Partial<IkasCategoryPropValue>);
+}

package/build/models/theme/page/component/prop-value/link.d.ts

@@ -0,0 +1,19 @@
+import { IkasThemePageType } from "../../index";
+export declare class IkasLinkPropValue {
+    id?: string | null;
+    linkType?: IkasLinkType | null;
+    label?: string | null;
+    pageId?: string | null;
+    pageType?: IkasThemePageType | null;
+    itemId?: string | null;
+    externalLink?: string | null;
+    fileUrl?: string | null;
+    pageComponentId?: string | null;
+    subLinks: IkasLinkPropValue[];
+    constructor(data?: Partial<IkasLinkPropValue>);
+}
+export declare enum IkasLinkType {
+    PAGE = "PAGE",
+    EXTERNAL = "EXTERNAL",
+    FILE = "FILE"
+}

package/build/models/theme/page/component/prop-value/product-detail.d.ts

@@ -0,0 +1,6 @@
+export declare class IkasProductDetailPropValue {
+    productId?: string | null;
+    variantId?: string | null;
+    usePageData?: boolean | null;
+    constructor(data: Partial<IkasProductDetailPropValue>);
+}

package/build/models/theme/page/component/prop-value/product-list.d.ts

@@ -0,0 +1,17 @@
+import { IkasProductListSortType, IkasProductListType } from "../../../../ui/index";
+export declare class IkasProductListPropValue {
+    id: string;
+    productListType: IkasProductListType;
+    initialSort?: IkasProductListSortType | null;
+    initialLimit?: number | null;
+    productCount?: number | null;
+    productIds?: IkasProductVariantId[] | null;
+    usePageFilter?: boolean | null;
+    category?: string | null;
+    constructor(data: Partial<IkasProductListPropValue>);
+}
+declare type IkasProductVariantId = {
+    productId: string;
+    variantId: string;
+};
+export {};

package/build/models/theme/page/index.d.ts

@@ -0,0 +1,40 @@
+import { IkasThemePageComponent } from "./component/index";
+export declare class IkasThemePage {
+    id: string;
+    name: string | null;
+    type: IkasThemePageType;
+    slug: string | null;
+    pageTitle: string | null;
+    description: string | null;
+    components: IkasThemePageComponent[];
+    specifications: IkasThemePageSpecification[] | null;
+    constructor(data: Partial<IkasThemePage>);
+}
+export declare class IkasThemePageSpecification {
+    id: string;
+    components: IkasThemePageComponent[];
+    constructor(data: Partial<IkasThemePageSpecification>);
+}
+export declare enum IkasThemePageType {
+    INDEX = "INDEX",
+    CATEGORY = "CATEGORY",
+    BRAND = "BRAND",
+    PRODUCT = "PRODUCT",
+    CUSTOM = "CUSTOM",
+    ACCOUNT = "ACCOUNT",
+    ADDRESSES = "ADDRESSES",
+    ORDERS = "ORDERS",
+    ORDER_DETAIL = "ORDER_DETAIL",
+    LOGIN = "LOGIN",
+    REGISTER = "REGISTER",
+    FORGOT_PASSWORD = "FORGOT_PASSWORD",
+    RECOVER_PASSWORD = "RECOVER_PASSWORD",
+    CART = "CART",
+    FAVORITE_PRODUCTS = "FAVORITE_PRODUCTS",
+    SEARCH = "SEARCH",
+    NOT_FOUND = "NOT_FOUND",
+    BLOG = "BLOG",
+    BLOG_INDEX = "BLOG_INDEX",
+    BLOG_CATEGORY = "BLOG_CATEGORY",
+    CHECKOUT = "CHECKOUT"
+}

package/build/models/theme/settings/index.d.ts

@@ -0,0 +1,13 @@
+import { IkasThemeColor } from "./prop/color/index";
+import { IkasThemeFavicon } from "./prop/favicon/index";
+export declare class IkasThemeSettings {
+    colors: IkasThemeColor[];
+    favicon: IkasThemeFavicon;
+    stockPreference: IkasThemeStockPreference;
+    constructor(data?: Partial<IkasThemeSettings>);
+}
+export declare enum IkasThemeStockPreference {
+    HIDE_OUT_OF_STOCK = "HIDE_OUT_OF_STOCK",
+    SHOW_ALL = "SHOW_ALL",
+    SHOW_OUT_OF_STOCK_AT_END = "SHOW_OUT_OF_STOCK_AT_END"
+}

package/build/models/theme/settings/prop/color/index.d.ts

@@ -0,0 +1,7 @@
+export declare class IkasThemeColor {
+    id: string;
+    displayName: string;
+    key: string;
+    color: string;
+    constructor(data: Partial<IkasThemeColor>);
+}

package/build/models/theme/settings/prop/favicon/index.d.ts

@@ -0,0 +1,4 @@
+export declare class IkasThemeFavicon {
+    id: string | null;
+    constructor(data?: Partial<IkasThemeFavicon>);
+}

package/build/models/theme/theme.d.ts

@@ -0,0 +1,16 @@
+import { IkasThemeComponent } from "./component/index";
+import { IkasThemeCustomData } from "./custom-data/index";
+import { IkasThemePage } from "./page/index";
+import { IkasThemeSettings } from "./settings/index";
+export declare const CHECKOUT_ID = "checkout";
+export declare class IkasTheme {
+    name: string;
+    components: IkasThemeComponent[];
+    pages: IkasThemePage[];
+    settings: IkasThemeSettings;
+    customData: IkasThemeCustomData[];
+    constructor(data?: Partial<IkasTheme>);
+    get headerComponent(): IkasThemeComponent | undefined;
+    get footerComponent(): IkasThemeComponent | undefined;
+    private createCheckoutData;
+}

package/build/models/ui/blog-category-list/index.d.ts

@@ -0,0 +1,52 @@
+import { IkasBlogCategory } from "../../data/blog/index";
+import { IkasBlogCategoryListPropValue } from "../../theme/page/component/prop-value/blog-category-list";
+export declare class IkasBlogCategoryList {
+    data: IkasBlogCategory[];
+    private _type;
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _blogCategoryListPropValue;
+    private _isLoading;
+    constructor(data: IkasBlogCategoryListParams);
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get isStatic(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private listBlogCategories;
+    private getInitial;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    toJSON(): {
+        data: IkasBlogCategory[];
+        type: IkasBlogCategoryListType;
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        blogCategoryListPropValue: IkasBlogCategoryListPropValue;
+    };
+}
+export declare type IkasBlogCategoryListParams = {
+    data?: IkasBlogCategory[];
+    type?: IkasBlogCategoryListType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    blogCategoryListPropValue: IkasBlogCategoryListPropValue;
+};
+export declare enum IkasBlogCategoryListType {
+    ALL = "ALL",
+    STATIC = "STATIC"
+}

package/build/models/ui/blog-list/index.d.ts

@@ -0,0 +1,56 @@
+import { IkasBlog } from "../../data/blog/index";
+import { IkasBlogListPropValue } from "../../theme/page/component/prop-value/blog-list";
+export declare class IkasBlogList {
+    data: IkasBlog[];
+    private _type;
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _blogListPropValue;
+    private _filterCategoryId;
+    private _isLoading;
+    constructor(data: IkasBlogListParams);
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get isStatic(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private listBlogs;
+    private getInitial;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    toJSON(): {
+        data: IkasBlog[];
+        type: IkasBlogListType;
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        blogListPropValue: IkasBlogListPropValue;
+        filterCategoryId: string | null;
+    };
+}
+export declare type IkasBlogListParams = {
+    data?: IkasBlog[];
+    type?: IkasBlogListType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    blogListPropValue: IkasBlogListPropValue;
+    filterCategoryId: string | null;
+};
+export declare enum IkasBlogListType {
+    ALL = "ALL",
+    STATIC = "STATIC",
+    CATEGORY = "CATEGORY"
+}

package/build/models/ui/brand-list/index.d.ts

@@ -0,0 +1,61 @@
+import { IkasBrand } from "../../data/index";
+import { IkasBrandListPropValue } from "../../theme/page/component/prop-value/brand-list";
+export declare class IkasBrandList {
+    data: IkasBrand[];
+    private _type;
+    private _sort;
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _brandListPropValue;
+    private _isLoading;
+    constructor(data: IkasBrandListParams);
+    get sort(): IkasBrandListSortType;
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get isStatic(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private getSortParams;
+    getInitial: () => Promise<void>;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    setSortType(sortType: IkasBrandListSortType): Promise<void>;
+    toJSON(): {
+        data: IkasBrand[];
+        type: IkasBrandListType;
+        sort: IkasBrandListSortType;
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        brandListPropValue: IkasBrandListPropValue;
+    };
+}
+export declare type IkasBrandListParams = {
+    data?: IkasBrand[];
+    type?: IkasBrandListType;
+    sort?: IkasBrandListSortType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    brandListPropValue: IkasBrandListPropValue;
+};
+export declare enum IkasBrandListType {
+    ALL = "ALL",
+    STATIC = "STATIC"
+}
+export declare enum IkasBrandListSortType {
+    A_Z = "A_Z",
+    Z_A = "Z_A"
+}

package/build/models/ui/category-list/index.d.ts

@@ -0,0 +1,61 @@
+import { IkasCategory } from "../../data/index";
+import { IkasCategoryListPropValue } from "../../theme/page/component/prop-value/category-list";
+export declare class IkasCategoryList {
+    data: IkasCategory[];
+    private _type;
+    private _sort;
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _categoryListPropValue;
+    private _isLoading;
+    constructor(data: IkasCategoryListParams);
+    get sort(): IkasCategoryListSortType;
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get isStatic(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private getSortParams;
+    getInitial: () => Promise<void>;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    setSortType(sortType: IkasCategoryListSortType): Promise<void>;
+    toJSON(): {
+        data: IkasCategory[];
+        type: IkasCategoryListType;
+        sort: IkasCategoryListSortType;
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        categoryListPropValue: IkasCategoryListPropValue;
+    };
+}
+export declare type IkasCategoryListParams = {
+    data?: IkasCategory[];
+    type?: IkasCategoryListType;
+    sort?: IkasCategoryListSortType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    categoryListPropValue: IkasCategoryListPropValue;
+};
+export declare enum IkasCategoryListType {
+    ALL = "ALL",
+    STATIC = "STATIC"
+}
+export declare enum IkasCategoryListSortType {
+    A_Z = "A_Z",
+    Z_A = "Z_A"
+}

package/build/models/ui/component-renderer/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+declare type RenderFunction = () => React.ReactNode;
+export declare class IkasComponentRenderer {
+    render: RenderFunction;
+    constructor(render: RenderFunction);
+}
+export {};

package/build/models/ui/customer-review-list/index.d.ts

@@ -0,0 +1,43 @@
+import { IkasCustomerReview } from "../../data/customer-review/index";
+export declare class IkasCustomerReviewList {
+    data: IkasCustomerReview[];
+    private _limit;
+    private _page;
+    private _count;
+    private _initialized;
+    private _minPage?;
+    private _productId;
+    private _isLoading;
+    constructor(data: IkasCustomerReviewListParams);
+    get limit(): number;
+    get page(): number;
+    get count(): number;
+    get pageCount(): number;
+    get isInitialized(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    private listCustomerReviews;
+    private getInitial;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    toJSON(): {
+        data: IkasCustomerReview[];
+        limit: number;
+        page: number;
+        count: number;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        productId: string;
+    };
+}
+export declare type IkasCustomerReviewListParams = {
+    data?: IkasCustomerReview[];
+    limit?: number;
+    page?: number;
+    count?: number;
+    initialized?: boolean;
+    minPage?: number;
+    productId: string;
+};

package/build/models/ui/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./blog-list/index";
+export * from "./blog-category-list/index";
+export { IkasBrandList, IkasBrandListType, IkasBrandListSortType, } from "./brand-list/index";
+export { IkasCategoryList, IkasCategoryListType, IkasCategoryListSortType, } from "./category-list/index";
+export type { IkasBrandListParams } from "./brand-list/index";
+export { IkasNavigationLink } from "./navigation-link/index";
+export { IkasProductDetail, IkasDisplayedVariantType, IkasDisplayedVariantValue, } from "./product-detail/index";
+export { IkasProductList, IkasProductListType, IkasProductListSortType, } from "./product-list/index";
+export * from "./product-attribute-detail/index";
+export * from "./product-attribute-list/index";
+export * from "./customer-review-list/index";
+export { Validator, ValidationStatus } from "./validator/index";
+export * from "./validator/rules/index";
+export { LoginForm } from "./validator/form/login";
+export { AddressForm } from "./validator/form/address";
+export { RegisterForm } from "./validator/form/register";
+export { ContactForm } from "./validator/form/contact-form";
+export { ForgotPasswordForm } from "./validator/form/forgot-password";
+export { RecoverPasswordForm } from "./validator/form/recover-password";
+export { AccountInfoForm } from "./validator/form/account-info";
+export { CustomerReviewForm } from "./validator/form/customer-review";
+export * from "./component-renderer/index";

package/build/models/ui/navigation-link/index.d.ts

@@ -0,0 +1,8 @@
+export declare class IkasNavigationLink {
+    href: string;
+    label: string;
+    subLinks: IkasNavigationLink[];
+    isExternal?: boolean | null;
+    itemId?: string;
+    constructor(href: string, label: string, subLinks: IkasNavigationLink[], isExternal?: boolean);
+}

package/build/models/ui/product-attribute-detail/index.d.ts

@@ -0,0 +1,8 @@
+import { IkasAttributePropValue } from "../../theme/page/component/prop-value/attribute";
+import { IkasProductDetail } from "../product-detail/index";
+export declare class IkasAttributeDetail {
+    productDetail: IkasProductDetail | null;
+    attributePropValue: IkasAttributePropValue;
+    constructor(productDetail: IkasProductDetail | null, attributePropValue: IkasAttributePropValue);
+    get values(): import("../../index").IkasProductAttributeValue[];
+}

package/build/models/ui/product-attribute-list/index.d.ts

@@ -0,0 +1,9 @@
+import { IkasProductAttributeMap } from "../../data/index";
+import { IkasProductDetail } from "../product-detail/index";
+import { IkasAttributeListPropValue } from "../../theme/page/component/prop-value/attribute-list";
+export declare class IkasAttributeList {
+    productDetail: IkasProductDetail | null;
+    attributeListPropValue: IkasAttributeListPropValue;
+    constructor(productDetail: IkasProductDetail | null, attributeListPropValue: IkasAttributeListPropValue);
+    get values(): IkasProductAttributeMap[];
+}

package/build/models/ui/product-detail/index.d.ts

@@ -0,0 +1,28 @@
+import { IkasProduct, IkasVariantValue, IkasCustomerReviewList } from "../../index";
+import { NextRouter } from "next/router";
+import { IkasProductVariant, IkasVariantType } from "../../data/index";
+export declare class IkasProductDetail {
+    product: IkasProduct;
+    selectedVariantValues: IkasVariantValue[];
+    private router?;
+    constructor(product: IkasProduct, selectedVariantValues: IkasVariantValue[], router?: NextRouter);
+    get mainVariantValue(): IkasVariantValue | undefined;
+    get selectedVariant(): IkasProductVariant;
+    get href(): string;
+    get hasStock(): boolean;
+    get displayedVariantTypes(): IkasDisplayedVariantType[];
+    get isCustomerReviewEnabled(): boolean;
+    get isCustomerReviewLoginRequired(): boolean;
+    getCustomerReviews(): Promise<IkasCustomerReviewList>;
+    selectVariantValue(variantValue: IkasVariantValue): void;
+}
+export declare type IkasDisplayedVariantValue = {
+    variant: IkasProductVariant;
+    variantValue: IkasVariantValue;
+    hasStock: boolean;
+    isSelected: boolean;
+};
+export declare type IkasDisplayedVariantType = {
+    variantType: IkasVariantType;
+    displayedVariantValues: IkasDisplayedVariantValue[];
+};

package/build/models/ui/product-list/index.d.ts

@@ -0,0 +1,132 @@
+import { IkasProductListPropValue, IkasThemePageType } from "../../theme/index";
+import { IkasProductDetail } from "../product-detail/index";
+import { IkasProductFilter } from "../../data/product-filter/index";
+import { NextRouter } from "next/router";
+import { IkasCategory, IkasFilterCategory } from "../../data/category/index";
+import { IkasBrand } from "../../data/index";
+export declare class IkasProductList {
+    data: IkasProductDetail[];
+    filters?: IkasProductFilter[] | null;
+    private _filterCategories?;
+    private _type;
+    private _pageType;
+    private _sort;
+    private _limit;
+    private _page;
+    private _infiniteScrollPage;
+    private _count;
+    private _searchKeyword;
+    private _initialized;
+    private _minPage?;
+    private _productListPropValue;
+    private _filterBrandId?;
+    private _filterCategoryId?;
+    private pageSpecificData?;
+    private _recommendFor?;
+    private _isLoading;
+    private _fetchRequestTime;
+    private router?;
+    constructor(data: IkasProductListParams, router?: NextRouter);
+    get sort(): IkasProductListSortType;
+    get limit(): number;
+    get pageType(): IkasThemePageType;
+    get page(): number;
+    get minPage(): number;
+    get count(): number;
+    get pageCount(): number;
+    get searchKeyword(): string;
+    set searchKeyword(value: string);
+    get isInitialized(): boolean;
+    get isFilterable(): boolean;
+    get isFiltered(): boolean | undefined;
+    get isStatic(): boolean;
+    get isDiscounted(): boolean;
+    get isRecommended(): boolean;
+    get isLastViewed(): boolean;
+    get isSearch(): boolean;
+    get hasPrev(): boolean;
+    get hasNext(): boolean;
+    get isLoading(): boolean;
+    get filterQueryParams(): string;
+    get filterCategories(): IkasFilterCategory[] | undefined;
+    get hasAppliedfilter(): boolean | undefined;
+    get isFeaturedSortEnabled(): boolean;
+    private setPageSpecificSort;
+    private getSortParams;
+    private searchProducts;
+    private getFilters;
+    private applyQueryParamFilters;
+    private applyFacets;
+    private applyFilters;
+    clearFilters(): void;
+    private getInitial;
+    getPrev: () => Promise<void>;
+    getNext: () => Promise<void>;
+    getPage: (page: number) => Promise<void>;
+    setSortType(sortType: IkasProductListSortType): Promise<void>;
+    onFilterCategoryClick(filterCategory: IkasFilterCategory, disableRoute?: boolean): Promise<void>;
+    toJSON(): {
+        data: IkasProductDetail[];
+        type: IkasProductListType;
+        pageType: IkasThemePageType;
+        sort: IkasProductListSortType;
+        limit: number;
+        page: number;
+        count: number;
+        searchKeyword: string;
+        initialized: boolean;
+        minPage: number | null | undefined;
+        filterBrandId: string | null | undefined;
+        filterCategoryId: string | null | undefined;
+        filterCategories: IkasFilterCategory[] | null | undefined;
+        filters: IkasProductFilter[] | null | undefined;
+        recommendFor: string | null | undefined;
+        productListPropValue: IkasProductListPropValue;
+        pageSpecificData: IkasCategory | IkasBrand | null | undefined;
+    };
+    setVisibleInfiniteScrollPage: (page: number) => void;
+    private restoreInfiniteScrollPage;
+    private getQueryParams;
+    private isBrowser;
+    private waitForCustomerStoreInit;
+    private handleListingEvent;
+    private searchDebouncer;
+    private searchAnalyticsDebouncer;
+}
+export declare type IkasProductListParams = {
+    data?: IkasProductDetail[];
+    type?: IkasProductListType;
+    pageType: IkasThemePageType;
+    sort?: IkasProductListSortType;
+    limit?: number;
+    page?: number;
+    count?: number;
+    searchKeyword?: string;
+    initialized?: boolean;
+    minPage?: number;
+    filterBrandId?: string;
+    filterCategoryId?: string;
+    filters?: IkasProductFilter[];
+    filterCategories?: IkasFilterCategory[];
+    recommendFor?: string;
+    productListPropValue: IkasProductListPropValue;
+    pageSpecificData?: IkasCategory | IkasBrand | null;
+};
+export declare enum IkasProductListType {
+    ALL = "ALL",
+    STATIC = "STATIC",
+    DISCOUNTED = "DISCOUNTED",
+    RECOMMENDED = "RECOMMENDED",
+    CATEGORY = "CATEGORY",
+    SEARCH = "SEARCH",
+    LAST_VIEWED = "LAST_VIEWED"
+}
+export declare enum IkasProductListSortType {
+    INCREASING_PRICE = "INCREASING_PRICE",
+    DECREASING_PRICE = "DECREASING_PRICE",
+    LAST_ADDED = "LAST_ADDED",
+    FIRST_ADDED = "FIRST_ADDED",
+    INCREASING_DISCOUNT = "INCREASING_DISCOUNT",
+    DECRASING_DISCOUNT = "DECRASING_DISCOUNT",
+    FEATURED = "FEATURED"
+}