ingeniuscliq-core 0.0.12 → 0.0.13

package/dist/components/ui/sidebar.d.ts

@@ -0,0 +1,69 @@
+import { VariantProps } from 'class-variance-authority';
+import { Button } from './button';
+import { Input } from './input';
+import { Separator } from './separator';
+import { TooltipContent } from './tooltip';
+import * as React from "react";
+type SidebarContextProps = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React.ComponentProps<"div"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React.ComponentProps<"div"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarRail({ className, ...props }: React.ComponentProps<"button">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<"main">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarInput({ className, ...props }: React.ComponentProps<typeof Input>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupLabel({ className, asChild, ...props }: React.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuBadge({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React.ComponentProps<"a"> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };

package/dist/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/dist/components/ui/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Slider };

package/dist/components/ui/sonner.d.ts

@@ -0,0 +1,3 @@
+import { ToasterProps } from 'sonner';
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster };

package/dist/components/ui/stepper.d.ts

@@ -0,0 +1,18 @@
+interface StepProps {
+    step: Step;
+    isCompleted?: boolean;
+    isActive?: boolean;
+    firstStep?: boolean;
+    lastStep?: boolean;
+}
+interface Step {
+    title: string;
+    icon: React.ReactNode;
+}
+declare const Step: React.FC<StepProps>;
+interface StepperProps {
+    steps: Step[];
+    currentStep: number;
+}
+export declare function Stepper({ steps, currentStep }: StepperProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+declare function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Switch };

package/dist/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/components/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare function Tabs({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TabsList({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/constants/menu.d.ts

@@ -0,0 +1,2 @@
+import { CoreMenuItem } from '../types/CoreMenu';
+export declare const SUB_MENU_HEADER: CoreMenuItem[];

package/dist/helpers/axiosGlobal.d.ts

@@ -0,0 +1,7 @@
+export declare const api: import('axios').AxiosInstance;
+/**
+ * Ensures the CSRF token is fetched once per session
+ * Use this function before making API calls that require CSRF protection
+ * @returns {Promise} A promise that resolves when the CSRF token is ready
+ */
+export declare const ensureCsrfToken: () => Promise<boolean>;

package/dist/helpers/strings.d.ts

@@ -0,0 +1 @@
+export declare function capitalizeFirstLetter(word: string): string;

package/dist/helpers/template.d.ts

@@ -0,0 +1,4 @@
+import { CoreDesignTemplate } from '../types/ui/template';
+export declare const getTemplateComponents: (template?: CoreDesignTemplate, keyComponents?: string[]) => import("react/jsx-runtime").JSX.Element;
+export declare const getTemplateStyles: (template?: CoreDesignTemplate) => {} | undefined;
+export declare const findComponentPath: (template: string, component: string) => string | undefined;

package/dist/helpers/tenant.d.ts

@@ -0,0 +1,3 @@
+export declare const getTenantURL: (withAPIPrefix?: boolean) => string;
+export declare const isCentralAccess: () => boolean;
+export declare const getTenantName: () => string;

package/dist/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/hooks/useI18n.d.ts

@@ -0,0 +1,5 @@
+export declare function useI18n(): {
+    t: import('i18next').TFunction<"translation", undefined>;
+    i18n: import('i18next').i18n;
+    toggleLanguage: () => void;
+};

package/dist/hooks/useNotification.d.ts

@@ -0,0 +1,6 @@
+export default function useNotify(): {
+    notify: (title: string, description?: string, duration?: number, action?: {
+        label: string;
+        onClick: () => void;
+    }) => void;
+};

package/dist/i18n/config.d.ts

@@ -0,0 +1,130 @@
+import { default as i18n } from 'i18next';
+export declare const resources: {
+    readonly en: {
+        readonly translation: {
+            readonly modules: {};
+            readonly messages: {
+                loading: string;
+                success: {
+                    create: string;
+                    update: string;
+                    delete: string;
+                };
+                error: {
+                    required: string;
+                    invalid: string;
+                    notFound: string;
+                };
+                confirmation: {
+                    delete: string;
+                    cancel: string;
+                };
+                validation: {
+                    name: string;
+                    lastname: string;
+                    email: string;
+                    password: string;
+                    passwordConfirmation: string;
+                    passwordConfirmationNotMatch: string;
+                    customer_name: string;
+                    customer_email: string;
+                    customer_phone: {
+                        required: string;
+                        prefix: string;
+                        length: string;
+                    };
+                    customer_address: string;
+                };
+            };
+            readonly fields: {
+                name: string;
+                lastname: string;
+                email: string;
+                password: string;
+                password_confirmation: string;
+                phone: string;
+                address: string;
+                note: string;
+                customer_name: string;
+                customer_email: string;
+                customer_phone: string;
+                customer_address: string;
+            };
+            readonly menu: {
+                store: string;
+                about: string;
+                contact: string;
+            };
+            readonly auth: {
+                login: string;
+                register: string;
+                noAccount: string;
+                alreadyHaveAccount: string;
+            };
+        };
+    };
+    readonly es: {
+        readonly translation: {
+            readonly modules: {};
+            readonly messages: {
+                loading: string;
+                success: {
+                    create: string;
+                    update: string;
+                    delete: string;
+                };
+                error: {
+                    required: string;
+                    invalid: string;
+                    notFound: string;
+                };
+                confirmation: {
+                    delete: string;
+                    cancel: string;
+                };
+                validation: {
+                    name: string;
+                    lastname: string;
+                    email: string;
+                    password: string;
+                    passwordConfirmation: string;
+                    passwordConfirmationNotMatch: string;
+                    customer_name: string;
+                    customer_email: string;
+                    customer_phone: {
+                        required: string;
+                        prefix: string;
+                        length: string;
+                    };
+                    customer_address: string;
+                };
+            };
+            readonly fields: {
+                name: string;
+                lastname: string;
+                email: string;
+                password: string;
+                password_confirmation: string;
+                phone: string;
+                address: string;
+                note: string;
+                customer_name: string;
+                customer_email: string;
+                customer_phone: string;
+                customer_address: string;
+            };
+            readonly menu: {
+                store: string;
+                about: string;
+                contact: string;
+            };
+            readonly auth: {
+                login: string;
+                register: string;
+                noAccount: string;
+                alreadyHaveAccount: string;
+            };
+        };
+    };
+};
+export default i18n;

package/dist/i18n/utils/loadModuleTranslations.d.ts

@@ -0,0 +1,8 @@
+interface ModuleTranslations {
+    [key: string]: any;
+}
+export declare const loadModuleTranslations: (moduleName: string, translations: {
+    en: ModuleTranslations;
+    es: ModuleTranslations;
+}) => void;
+export {};

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * from './classes/CoreBuilder';
-export * from './components/customs';
+export * from './components/customs/index';
 export { CoreHeader } from './components/templates/partials/CoreHeader';

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 default function AuthDecorator(): import("react/jsx-runtime").JSX.Element;

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export default 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;
+}