ingeniuscliq-core 0.0.12 → 0.1.0

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/modules/CoreAuth/components/layouts/partials/AuthDecorator.d.ts

@@ -0,0 +1 @@
+export declare function AuthDecorator(): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreAuth/components/layouts/partials/AuthProfileDeleteAccountForm.d.ts

@@ -0,0 +1 @@
+export declare function AuthProfileDeleteAccountForm(): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreAuth/components/layouts/partials/AuthProfileForm.d.ts

@@ -0,0 +1 @@
+export declare function AuthProfileForm(): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreAuth/components/layouts/partials/AuthProfileUpdatePassForm.d.ts

@@ -0,0 +1 @@
+export declare function AuthProfileUpdatePassForm(): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreAuth/components/layouts/partials/AuthUserMenu.d.ts

@@ -0,0 +1 @@
+export declare function AuthUserMenu(): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreAuth/constants/auth.d.ts

@@ -0,0 +1,5 @@
+export declare const LOGIN_ROUTE = "/api/login";
+export declare const REGISTER_ROUTE = "/api/register";
+export declare const LOGOUT_ROUTE = "/api/logout";
+export declare const REFRESH_TOKEN_ROUTE = "/api/refresh-token";
+export declare const USER_ROUTE = "/api/user";

package/dist/modules/CoreAuth/hooks/useAuth.d.ts

@@ -0,0 +1,18 @@
+import { CoreLoginCredentials, CoreRegisterCredentials, CoreUser } from '../types/CoreAuth';
+export declare function useAuth(): {
+    user: CoreUser | null;
+    token: string | null;
+    refreshToken: string | null;
+    isAuthenticated: boolean;
+    loading: boolean;
+    error: string | null;
+    getUser: () => Promise<any>;
+    login: <T extends CoreLoginCredentials>(credentials: T) => Promise<any>;
+    register: <T extends CoreRegisterCredentials>(credentials: T) => Promise<any>;
+    logout: () => Promise<void>;
+    refreshUserToken: () => Promise<any>;
+    updateUser: (userData: Partial<CoreUser>) => void;
+    setUser: (user: CoreUser | null) => void;
+    setError: (error: string | null) => void;
+    reset: () => void;
+};

package/dist/modules/CoreAuth/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/CoreAuth/services/base.d.ts

@@ -0,0 +1,23 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { CoreLoginCredentials, CoreRegisterCredentials } from '../types/CoreAuth';
+interface CoreAuthRoutes {
+    login: string;
+    register: string;
+    logout: string;
+    refreshToken: string;
+    user: string;
+}
+/**
+ * Base class that can be extended by concrete services
+*/
+export declare class CoreAuthBaseService {
+    private readonly api;
+    private readonly routes;
+    constructor(routes?: CoreAuthRoutes, api?: AxiosInstance);
+    getUser(): Promise<import('axios').AxiosResponse<any, any>>;
+    login<T extends CoreLoginCredentials>(credentials: T): Promise<import('axios').AxiosResponse<any, any>>;
+    register<T extends CoreRegisterCredentials>(credentials: T): Promise<import('axios').AxiosResponse<any, any>>;
+    logout(config?: AxiosRequestConfig): Promise<import('axios').AxiosResponse<any, any>>;
+    refreshToken(config?: AxiosRequestConfig): Promise<import('axios').AxiosResponse<any, any>>;
+}
+export {};

package/dist/modules/CoreAuth/stores/authStore.d.ts

@@ -0,0 +1,22 @@
+import { CoreAuthStore, CoreUser } from '../types/CoreAuth';
+export declare const useAuthStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreAuthStore<CoreUser>>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreAuthStore<CoreUser>, {
+            user: CoreUser | null;
+            token: string | null;
+            refreshToken: string | null;
+            isAuthenticated: boolean;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CoreAuthStore<CoreUser>) => void) => () => void;
+        onFinishHydration: (fn: (state: CoreAuthStore<CoreUser>) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreAuthStore<CoreUser>, {
+            user: CoreUser | null;
+            token: string | null;
+            refreshToken: string | null;
+            isAuthenticated: boolean;
+        }>>;
+    };
+}>;

package/dist/modules/CoreAuth/types/CoreAuth.d.ts

@@ -0,0 +1,25 @@
+import { BaseStore } from '../../../types/BaseStore';
+import { BaseType } from '../../../types/BaseType';
+export interface CoreUser extends BaseType {
+    name?: string;
+    lastname?: string;
+    email: string;
+    phone?: string;
+    address?: string;
+}
+export interface CoreLoginCredentials {
+    email: string;
+    password: string;
+}
+export interface CoreRegisterCredentials extends CoreLoginCredentials {
+    name?: string;
+}
+export interface CoreAuthStore<T extends CoreUser> extends BaseStore {
+    user: T | null;
+    token: string | null;
+    refreshToken: string | null;
+    isAuthenticated: boolean;
+    setUser: (user: T | null) => void;
+    setToken: (token: string | null) => void;
+    setRefreshToken: (token: string | null) => void;
+}

package/dist/modules/CoreCustomization/classes/CoreCustomizationBuilder.d.ts

@@ -0,0 +1,30 @@
+import { CoreBuilder } from '../../../classes/CoreBuilder';
+import { CoreDesignTemplateSettings, CoreDesignTemplateStyles } from '../../../types/ui/template';
+import { CoreCustomizationStore } from '../types/CoreCustomization';
+import { CoreCustomizationBaseService } from '../services/base';
+export declare class CoreCustomizationBuilder implements CoreBuilder {
+    protected customizationService: CoreCustomizationBaseService;
+    protected initialState: Pick<CoreCustomizationStore, "template" | "components" | "styles" | "settings" | "loading" | "error">;
+    constructor(service?: CoreCustomizationBaseService, initialState?: any);
+    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreCustomizationStore>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreCustomizationStore, {
+                template: string | null;
+                components: string[] | null;
+                styles: CoreDesignTemplateStyles[] | null;
+                settings: CoreDesignTemplateSettings | null;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: CoreCustomizationStore) => void) => () => void;
+            onFinishHydration: (fn: (state: CoreCustomizationStore) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreCustomizationStore, {
+                template: string | null;
+                components: string[] | null;
+                styles: CoreDesignTemplateStyles[] | null;
+                settings: CoreDesignTemplateSettings | null;
+            }>>;
+        };
+    }>;
+}

package/dist/modules/CoreCustomization/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/CoreCustomization/services/base.d.ts

@@ -0,0 +1,10 @@
+import { BaseService } from '../../../services/base';
+import { BaseApiResponse } from '../../../types/contracts/BaseApiResponse';
+import { CoreDesignTemplate } from '../../../types/ui/template';
+/**
+ * Base class that can be extended by concrete services
+*/
+export declare class CoreCustomizationBaseService extends BaseService {
+    constructor();
+    fetchTemplate(): Promise<import('axios').AxiosResponse<BaseApiResponse<CoreDesignTemplate>, any>>;
+}

package/dist/modules/CoreCustomization/types/CoreCustomization.d.ts

@@ -0,0 +1,22 @@
+import { BaseType } from '../../../types/BaseType';
+import { BaseStore } from '../../../types/BaseStore';
+import { CoreDesignTemplate, CoreDesignTemplateSettings, CoreDesignTemplateStyles } from '../../../types/ui/template';
+/**
+ * CoreCustomization base type
+*/
+export interface CoreCustomization extends BaseType {
+    template: string | null;
+    styles: CoreDesignTemplateStyles[] | null;
+    settings: CoreDesignTemplateSettings | null;
+}
+export interface CoreCustomizationStore extends BaseStore {
+    template: string | null;
+    components: string[] | null;
+    styles: CoreDesignTemplateStyles[] | null;
+    settings: CoreDesignTemplateSettings | null;
+    fetchTemplate: () => Promise<CoreDesignTemplate>;
+    setTemplate: (template: string) => void;
+    setComponents: (components: string[]) => void;
+    setStyles: (styles: CoreDesignTemplateStyles[]) => void;
+    setSettings: (settings: CoreDesignTemplateSettings) => void;
+}

package/dist/modules/CoreOrder/classes/CoreOrderBuilder.d.ts

@@ -0,0 +1,23 @@
+import { CoreBuilder } from '../../../classes/CoreBuilder';
+import { CoreOrderBaseService } from '../services/base';
+import { CoreOrder, CoreOrderStore } from '../types/CoreOrder';
+export declare class CoreOrderBuilder<T> implements CoreBuilder {
+    protected orderService: CoreOrderBaseService;
+    protected initialState: Pick<CoreOrderStore<T>, 'order'>;
+    constructor(orderService?: CoreOrderBaseService, initialState?: Pick<CoreOrderStore<T>, 'order'>);
+    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreOrderStore<T>>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreOrderStore<T>, {
+                order: CoreOrder<T>;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: CoreOrderStore<T>) => void) => () => void;
+            onFinishHydration: (fn: (state: CoreOrderStore<T>) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreOrderStore<T>, {
+                order: CoreOrder<T>;
+            }>>;
+        };
+    }>;
+}

package/dist/modules/CoreOrder/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/CoreOrder/services/base.d.ts

@@ -0,0 +1,7 @@
+import { BaseService } from '../../../services/base';
+/**
+ * Base class that can be extended by concrete services
+*/
+export declare class CoreOrderBaseService extends BaseService {
+    constructor();
+}

package/dist/modules/CoreOrder/types/CoreOrder.d.ts

@@ -0,0 +1,41 @@
+import { BaseType } from '../../../types/BaseType';
+import { IOrderActions } from './interfaces/OrderActions';
+/**
+ * CoreOrder base type
+*/
+export interface CoreOrder<T> extends BaseType {
+    customer_name: string;
+    customer_email: string;
+    customer_phone: string;
+    customer_address: string;
+    note?: string;
+    order_number: string;
+    userable_type: string;
+    userable_id: number;
+    items_subtotal: number;
+    current_base_currency: string;
+    currency: string;
+    exchange_rate: number;
+    status: string;
+    base_total_amount_in_cents: number;
+    base_total_amount_formatted: string;
+    total_amount_in_cents: number;
+    total_amount_formatted: string;
+    status_name: string;
+    allowed_next_statuses: {
+        identifier: string;
+        name: string;
+    }[];
+    products: T[];
+}
+export interface CoreOrderStore<T> extends IOrderActions<T> {
+    order: CoreOrder<T>;
+}
+export interface CoreOrderForm extends BaseType {
+    customer_name: string;
+    customer_email: string;
+    customer_phone: string;
+    customer_address: string;
+    note?: string;
+    payform_id?: string;
+}

package/dist/modules/CoreOrder/types/interfaces/OrderActions.d.ts

@@ -0,0 +1,14 @@
+import { AxiosResponse } from 'axios';
+import { BaseApiResponse } from '../../../../types/contracts/BaseApiResponse';
+import { CoreOrderForm, CoreOrder } from '../CoreOrder';
+export interface IOrderActions<T> {
+    createOrder: (order: CoreOrderForm) => Promise<BaseApiResponse<CreateOrderResponse<CoreOrder<T>>>>;
+    fetchOrder: (order_id: string | number) => Promise<BaseApiResponse<CoreOrder<T>>>;
+    getOrder: () => CoreOrder<T>;
+}
+export interface IOrderActionsService<T> {
+    createOrder: (order: CoreOrderForm) => Promise<AxiosResponse<BaseApiResponse<CreateOrderResponse<CoreOrder<T>>>>>;
+}
+export interface CreateOrderResponse<T> {
+    order: T;
+}

package/dist/modules/CorePayForm/classes/CorePayFormBuilder.d.ts

@@ -0,0 +1,23 @@
+import { CoreBuilder } from '../../../classes/CoreBuilder';
+import { CorePayFormBaseService } from '../services/base';
+import { CorePayForm, CorePayFormStore } from '../types/CorePayForm';
+export declare class CorePayFormBuilder implements CoreBuilder {
+    protected payFormService: CorePayFormBaseService;
+    protected initialState: Pick<CorePayFormStore<CorePayForm>, "payForms" | "loading" | "error">;
+    constructor(service?: CorePayFormBaseService, initialState?: any);
+    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CorePayFormStore<CorePayForm>>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CorePayFormStore<CorePayForm>, {
+                payForms: import('../../..').BasePagination<CorePayForm> | null;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: CorePayFormStore<CorePayForm>) => void) => () => void;
+            onFinishHydration: (fn: (state: CorePayFormStore<CorePayForm>) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CorePayFormStore<CorePayForm>, {
+                payForms: import('../../..').BasePagination<CorePayForm> | null;
+            }>>;
+        };
+    }>;
+}

package/dist/modules/CorePayForm/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/CorePayForm/services/base.d.ts

@@ -0,0 +1,7 @@
+import { BaseService } from '../../../services/base';
+/**
+ * Base class that can be extended by concrete services
+*/
+export declare class CorePayFormBaseService extends BaseService {
+    constructor();
+}

package/dist/modules/CorePayForm/types/CorePayForm.d.ts

@@ -0,0 +1,19 @@
+import { BaseStore } from '../../../types/BaseStore';
+import { BaseType } from '../../../types/BaseType';
+import { BaseApiResponsePagination } from '../../../types/contracts/BaseApiResponse';
+import { BasePagination } from '../../../types/contracts/BasePagination';
+/**
+ * CorePayForm base type
+*/
+export interface CorePayForm extends BaseType {
+    name: string;
+    icon: string;
+    description: string;
+    currencies: string[];
+}
+export interface CorePayFormStore<T extends CorePayForm> extends BaseStore {
+    payForms: BasePagination<T> | null;
+    setPayForms: (payForms: BasePagination<T> | null) => void;
+    getPayForms: () => BasePagination<T> | null;
+    fetchPayForms: (params?: Record<string, any>) => Promise<BaseApiResponsePagination<T>>;
+}

package/dist/modules/CoreProduct/classes/CoreProductBuilder.d.ts

@@ -0,0 +1,25 @@
+import { CoreBuilder } from '../../../classes/CoreBuilder';
+import { CoreProductBaseService } from '../services/base';
+import { CoreProduct, CoreProductStore } from '../types/CoreProduct';
+export declare class CoreProductBuilder implements CoreBuilder {
+    protected productService: CoreProductBaseService;
+    protected initialState: Pick<CoreProductStore<CoreProduct>, "productDetails" | "products" | "loading" | "error">;
+    constructor(service?: CoreProductBaseService, initialState?: any);
+    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreProductStore<CoreProduct>>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreProductStore<CoreProduct>, {
+                productDetails: CoreProduct | null;
+                products: import('../../..').BasePagination<CoreProduct> | null;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: CoreProductStore<CoreProduct>) => void) => () => void;
+            onFinishHydration: (fn: (state: CoreProductStore<CoreProduct>) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreProductStore<CoreProduct>, {
+                productDetails: CoreProduct | null;
+                products: import('../../..').BasePagination<CoreProduct> | null;
+            }>>;
+        };
+    }>;
+}

package/dist/modules/CoreProduct/components/layouts/partials/TabHead.d.ts

@@ -0,0 +1,6 @@
+import { BaseStyleProps } from '../../../../../types/ui/main';
+interface TabHeadProps extends BaseStyleProps {
+    readonly title: string;
+}
+export declare function TabHead({ title, className }: TabHeadProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/cards/CoreProductCard.d.ts

@@ -0,0 +1,15 @@
+import { CoreProduct } from '../../../types/CoreProduct';
+import { BaseStyleProps } from '../../../../../types/ui/main';
+import { CoreProductCardActionsEvents } from './CoreProductCardActions';
+interface CoreProductCardProps extends BaseStyleProps, Omit<CoreProductCardActionsEvents, 'onAddToCart'>, CoreProductCardEvents {
+    readonly product: CoreProduct;
+    readonly renderActions?: React.ReactNode;
+    readonly loadingAddToCart?: boolean;
+    readonly renderAddons?: React.ReactNode;
+}
+interface CoreProductCardEvents {
+    onClick: (product: CoreProduct) => void;
+    onAddToCart: (product: CoreProduct, quantity: number) => void;
+}
+export declare function CoreProductCard({ product, className, renderAddons, renderActions, loadingAddToCart, onUpdateQuantity, onAddToCart, onClick }: CoreProductCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/cards/CoreProductCardActions.d.ts

@@ -0,0 +1,18 @@
+import { BaseStyleProps, BaseVariantProps } from '../../../../../types/ui/main';
+export interface CoreProductCardActionsProps extends BaseStyleProps, CoreProductCardActionsEvents, BaseVariantProps {
+    readonly disabledColor?: boolean;
+    readonly productQuantity?: number;
+    readonly minValue?: number;
+    readonly maxValue?: number;
+    readonly colorLoading?: string;
+    readonly loading?: boolean;
+}
+export interface CoreProductCardActionsEvents {
+    onUpdateQuantity?: (quantity: number) => void;
+    onAddToCart?: (quantity: number) => void;
+    onValidateUpdateQuantity?: () => boolean;
+    onValidateAddToCart?: () => boolean;
+    onErrorUpdateQuantity?: () => void;
+    onErrorAddToCart?: () => void;
+}
+export declare function CoreProductCardActions({ disabledColor, variant, productQuantity, minValue, maxValue, colorLoading, loading, className, onUpdateQuantity, onAddToCart, onValidateUpdateQuantity, onValidateAddToCart, onErrorAddToCart, onErrorUpdateQuantity }: CoreProductCardActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreProduct/components/ui/cards/CoreProductCartItemAsideCard.d.ts

@@ -0,0 +1,7 @@
+import { CoreProduct } from '../../../types/CoreProduct';
+interface CoreProductCartItemAsideCardProps<T extends CoreProduct> {
+    product: T;
+    quantity: number;
+}
+export declare function CoreProductCartItemAsideCard<T extends CoreProduct>({ product, quantity }: CoreProductCartItemAsideCardProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/cards/CoreProductCartItemCard.d.ts

@@ -0,0 +1,8 @@
+import { CoreProduct } from '../../../types/CoreProduct';
+interface CoreProductCartItemCardProps<T extends CoreProduct> {
+    product: T;
+    quantity: number;
+    actions: React.ReactNode;
+}
+export declare function CoreProductCartItemCard<T extends CoreProduct>({ product, actions, quantity }: CoreProductCartItemCardProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/cards/CoreProductCartSummaryCard.d.ts

@@ -0,0 +1,7 @@
+import { CoreProduct } from '../../../types/CoreProduct';
+import { BaseProps } from '../../../../../types/ui/main';
+interface CoreProductCartSummaryCardProps<T extends CoreProduct> extends BaseProps {
+    product: T;
+}
+export declare function CoreProductCartSummaryCard<T extends CoreProduct>({ product, children, className }: CoreProductCartSummaryCardProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/cards/addons/WarrantyLabel.d.ts

@@ -0,0 +1,10 @@
+export declare enum SUPPORTED_WARRANTY_VARIANTS_ENUM {
+    primary = "primary",
+    secondary = "secondary"
+}
+export type SUPPORTED_WARRANTY_VARIANTS = keyof typeof SUPPORTED_WARRANTY_VARIANTS_ENUM;
+export interface WarrantyLabelProps {
+    readonly warrantyText?: string;
+    readonly variant: SUPPORTED_WARRANTY_VARIANTS_ENUM;
+}
+export declare function WarrantyLabel({ warrantyText, variant }: WarrantyLabelProps): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreProduct/components/ui/cards/skeletons/CoreProductCardSkeleton.d.ts

@@ -0,0 +1,5 @@
+import { BaseStyleProps } from '../../../../../../types/ui/main';
+interface CoreProductCardSkeletonProps extends BaseStyleProps {
+}
+export declare function CoreProductCardSkeleton({ className }: CoreProductCardSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/cards/skeletons/CoreProductCartItemCardSkeleton.d.ts

@@ -0,0 +1 @@
+export declare function CoreProductCartItemCardSkeleton(): import("react/jsx-runtime").JSX.Element;

package/dist/modules/CoreProduct/components/ui/cards/skeletons/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CoreProductCardSkeleton';
+export * from './CoreProductCartItemCardSkeleton';

package/dist/modules/CoreProduct/components/ui/carousels/CoreProductImageCarousel.d.ts

@@ -0,0 +1,8 @@
+import { BaseProps } from '../../../../../types/ui/main';
+import { CoreImage } from '../../../../../types/CoreImage';
+interface CoreProductImageCarouselProps<T extends CoreImage> extends BaseProps {
+    readonly renderAddons?: React.ReactNode;
+    readonly images: T[];
+}
+export declare function CoreProductImageCarousel<T extends CoreImage>({ className, renderAddons, images }: CoreProductImageCarouselProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/components/ui/containers/CoreProductGrid.d.ts

@@ -0,0 +1,19 @@
+import { BaseStyleProps } from '../../../../../types/ui/main';
+import { BasePagination } from '../../../../../types/contracts/BasePagination';
+import { CoreProduct } from '../../../types/CoreProduct';
+interface CoreProductGridProps<T extends CoreProduct> extends BaseStyleProps, CoreProductGridEvents<T> {
+    readonly products: BasePagination<T>;
+    readonly component?: React.ComponentType<any>;
+    readonly classNameItems?: string;
+    readonly loading?: boolean;
+    readonly skeleton?: React.ComponentType<any>;
+    readonly skeletonItems?: number;
+    readonly skeletonClassName?: string;
+    [key: string]: any;
+}
+interface CoreProductGridEvents<T extends CoreProduct> {
+    onItemClick?: (product: T) => void;
+    onPageChange?: (page: number) => void;
+}
+export declare function CoreProductGrid<T extends CoreProduct>({ products, onPageChange, component: Component, className, classNameItems, loading, skeleton: Skeleton, skeletonItems, skeletonClassName, onItemClick, ...props }: CoreProductGridProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreProduct/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/CoreProduct/services/base.d.ts

@@ -0,0 +1,7 @@
+import { BaseService } from '../../../services/base';
+/**
+ * Base class that can be extended by concrete services
+*/
+export declare class CoreProductBaseService extends BaseService {
+    constructor();
+}

package/dist/modules/CoreProduct/types/CoreProduct.d.ts

@@ -0,0 +1,33 @@
+import { BasePagination } from '../../../types/contracts/BasePagination';
+import { BaseStore } from '../../../types/BaseStore';
+import { BaseType } from '../../../types/BaseType';
+import { BaseImagesType } from '../../../types/interfaces/BaseImageType';
+import { BaseSlugType } from '../../../types/interfaces/BaseSlugType';
+import { BaseVisibleType } from '../../../types/interfaces/BaseVisibleType';
+import { HasProductCategories } from './CoreProductCategory';
+import { BaseApiResponse, BaseApiResponsePagination } from '../../../types/contracts/BaseApiResponse';
+/**
+ * CoreProduct base type
+*/
+export interface CoreProduct extends BaseType, BaseSlugType, BaseImagesType, BaseVisibleType, HasProductCategories {
+    name: string;
+    sku: string;
+    description: string;
+    regular_price: number;
+    sale_price: number;
+    handle_stock: boolean;
+    stock: number;
+    stock_for_sale: number;
+    unit_of_measurement: string;
+    short_description: string;
+}
+export interface CoreProductStore<T extends CoreProduct> extends BaseStore {
+    productDetails: T | null;
+    products: BasePagination<T> | null;
+    setProducts: (products: BasePagination<T> | null) => void;
+    setProductDetails: (product: T | null) => void;
+    fetchProducts: (params?: Record<string, any>) => Promise<BaseApiResponsePagination<T>>;
+    getProducts: () => BasePagination<T> | null;
+    getProductDetails: () => T | null;
+    fetchProductDetails: (id: string | number) => Promise<BaseApiResponse<T>>;
+}

package/dist/modules/CoreProduct/types/CoreProductCategory.d.ts

@@ -0,0 +1,10 @@
+import { BaseType } from '../../../types/BaseType';
+export interface CoreProductCategory extends BaseType {
+    name: string;
+}
+export interface HasProductCategories {
+    categories?: CoreProductCategory[];
+}
+export interface HasProbablyProductCategories {
+    categories?: CoreProductCategory[];
+}

package/dist/modules/CoreShopCart/classes/CoreShopCartBuilder.d.ts

@@ -0,0 +1,25 @@
+import { CoreShopCartBaseService } from '../services/base';
+import { CoreShopCartStore } from '../types/CoreShopCart';
+import { CoreBuilder } from '../../../classes/CoreBuilder';
+export declare class CoreShopCartBuilder<T> implements CoreBuilder {
+    protected shopCartService: CoreShopCartBaseService<T>;
+    protected initialState: Pick<CoreShopCartStore<T>, 'cart' | 'cartItems'>;
+    constructor(service?: CoreShopCartBaseService<T>, initialState?: Pick<CoreShopCartStore<T>, 'cart' | 'cartItems'>);
+    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreShopCartStore<T>>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreShopCartStore<T>, {
+                cart: import('../types/CoreShopCart').CoreShopCart<T>;
+                cartItems: import('../types/CoreShopCart').CoreCartItem<T>[];
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: CoreShopCartStore<T>) => void) => () => void;
+            onFinishHydration: (fn: (state: CoreShopCartStore<T>) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreShopCartStore<T>, {
+                cart: import('../types/CoreShopCart').CoreShopCart<T>;
+                cartItems: import('../types/CoreShopCart').CoreCartItem<T>[];
+            }>>;
+        };
+    }>;
+}

package/dist/modules/CoreShopCart/components/layouts/partials/CoreShopCartAside.d.ts

@@ -0,0 +1,12 @@
+import { BaseProps } from '../../../../../types/ui/main';
+interface CoreShopCartAsideProps extends CoreShopCartAsideEvents, BaseProps {
+    title: string;
+    containerClassName?: string;
+    renderTriggerAction?: React.ReactNode;
+}
+interface CoreShopCartAsideEvents {
+    onClose?: () => void;
+    onGoToCart?: () => void;
+}
+export declare function CoreShopCartAside({ title, className, containerClassName, children, onClose, onGoToCart, renderTriggerAction }: CoreShopCartAsideProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreShopCart/components/layouts/partials/CoreShopCartIcon.d.ts

@@ -0,0 +1,7 @@
+import { BaseStyleProps } from '../../../../../types/ui/main';
+interface CoreShopCartIconProps extends BaseStyleProps {
+    totalItems: number;
+    totalPrice: string;
+}
+export declare function CoreShopCartIcon({ totalItems, totalPrice, className }: CoreShopCartIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreShopCart/components/ui/cards/CoreCartItemAsideCard.d.ts

@@ -0,0 +1,9 @@
+import { BaseProps } from '../../../../../types/ui/main';
+import { CoreCartItem } from '../../../types/CoreShopCart';
+interface CoreCartItemAsideCartProps<T extends CoreCartItem<K>, K> extends BaseProps {
+    cartItem: T;
+    onAddToCart: (product_id: string | number, quantity: number) => void;
+    onRemoveFromCart: (product_id: string | number) => void;
+}
+export declare function CoreCartItemAsideCard<T extends CoreCartItem<K>, K>({ className, cartItem, children, onAddToCart, onRemoveFromCart }: CoreCartItemAsideCartProps<T, K>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/modules/CoreShopCart/components/ui/cards/skeletons/CoreCartItemAsideCardSkeleton.d.ts

@@ -0,0 +1,4 @@
+interface CoreCartItemAsideCardSkeletonProps extends React.PropsWithChildren {
+}
+export declare function CoreCartItemAsideCardSkeleton({ children }: CoreCartItemAsideCardSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export {};