ingeniuscliq-core 0.3.48 → 0.4.1

package/dist/modules/CoreAuth/classes/CoreAuthBuilder.d.ts

@@ -1,15 +1,13 @@
 import { CoreAuthStore, CoreUser } from '../types';
 import { CoreAuthBaseService } from '../services';
 export declare class CoreAuthBuilder<T extends CoreUser> {
-    protected authService: CoreAuthBaseService;
-    protected initialState: Pick<CoreAuthStore<T>, "user" | "token" | "refreshToken" | "isAuthenticated" | "loading" | "error">;
-    constructor(authService?: CoreAuthBaseService, initialState?: Partial<CoreAuthStore<T>>);
+    protected authService: CoreAuthBaseService<T>;
+    protected initialState: Pick<CoreAuthStore<T>, "user" | "isAuthenticated" | "loading" | "error">;
+    constructor(authService?: CoreAuthBaseService<T>, initialState?: Partial<CoreAuthStore<T>>);
     build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreAuthStore<T>>, "persist"> & {
         persist: {
             setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreAuthStore<T>, {
                 user: T | null;
-                token: string | null;
-                refreshToken: string | null;
                 isAuthenticated: boolean;
             }>>) => void;
             clearStorage: () => void;
@@ -19,8 +17,6 @@ export declare class CoreAuthBuilder<T extends CoreUser> {
             onFinishHydration: (fn: (state: CoreAuthStore<T>) => void) => () => void;
             getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreAuthStore<T>, {
                 user: T | null;
-                token: string | null;
-                refreshToken: string | null;
                 isAuthenticated: boolean;
             }>>;
         };

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

@@ -1,18 +1,16 @@
 export declare function useAuth(): {
     user: import('../types').CoreUser | null;
-    token: string | null;
-    refreshToken: string | null;
     isAuthenticated: boolean;
     loading: boolean;
     error: string | null;
-    getUser: () => Promise<import('../types').CoreUser>;
+    getUser: () => Promise<import('../../..').BaseApiResponse<import('../types').CoreGetUserResponse<import('../types').CoreUser>>>;
     login: <K extends import('../types').CoreLoginCredentials>(credentials: K) => Promise<import('../../..').BaseApiResponse<import('../types').CoreAuthLoginResponse<import('../types').CoreUser>>>;
     register: <K extends import('../types').CoreRegisterCredentials>(credentials: K) => Promise<import('../../..').BaseApiResponse<import('../types').CoreAuthRegisterResponse<import('../types').CoreUser>>>;
     logout: () => void;
     refreshUserToken: () => Promise<any>;
+    updateUser: (userId: Pick<import('../types').CoreUser, "id">, updateUserData: Partial<import('../types').CoreUser>, actions?: import('../../..').CoreActions) => void;
+    deleteUser: (userId: Pick<import('../types').CoreUser, "id">, actions?: import('../../..').CoreActions) => void;
     setUser: (user: import('../types').CoreUser | null) => void;
-    setToken: (token: string | null) => void;
-    setRefreshToken: (token: string | null) => void;
     setLoading: (loading: boolean) => void;
     setError: (error: string | null) => void;
     reset: () => void;

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

@@ -1,5 +1,7 @@
-import { AxiosInstance, AxiosRequestConfig } from 'axios';
-import { CoreLoginCredentials, CoreRegisterCredentials } from '../types/CoreAuth';
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { CoreGetUserResponse, CoreLoginCredentials, CoreRegisterCredentials, CoreUser } from '../types/CoreAuth';
+import { BaseApiResponse } from '../../../types';
+import { BaseService } from '../../../services';
 interface CoreAuthRoutes {
     login: string;
     register: string;
@@ -10,14 +12,15 @@ interface CoreAuthRoutes {
 /**
  * Base class that can be extended by concrete services
 */
-export declare class CoreAuthBaseService {
-    private readonly api;
+export declare class CoreAuthBaseService<T extends CoreUser> extends BaseService {
     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>>;
+    getUser(): Promise<AxiosResponse<BaseApiResponse<CoreGetUserResponse<T>>, any>>;
+    login<T extends CoreLoginCredentials>(credentials: T): Promise<AxiosResponse<any, any>>;
+    register<T extends CoreRegisterCredentials>(credentials: T): Promise<AxiosResponse<any, any>>;
+    logout(config?: AxiosRequestConfig): Promise<AxiosResponse<any, any>>;
+    refreshToken(config?: AxiosRequestConfig): Promise<AxiosResponse<any, any>>;
+    updateUser(userId: Pick<T, "id">, updateUserData: Partial<T>): Promise<AxiosResponse<BaseApiResponse<T>, any>>;
+    deleteUser: (userId: Pick<T, "id">) => Promise<AxiosResponse<BaseApiResponse<null>, any>>;
 }
 export {};

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

@@ -3,8 +3,6 @@ export declare const useAuthStore: import('zustand').UseBoundStore<Omit<import('
     persist: {
         setOptions: (options: Partial<import('zustand/middleware').PersistOptions<import('../types').CoreAuthStore<CoreUser>, {
             user: CoreUser | null;
-            token: string | null;
-            refreshToken: string | null;
             isAuthenticated: boolean;
         }>>) => void;
         clearStorage: () => void;
@@ -14,8 +12,6 @@ export declare const useAuthStore: import('zustand').UseBoundStore<Omit<import('
         onFinishHydration: (fn: (state: import('../types').CoreAuthStore<CoreUser>) => void) => () => void;
         getOptions: () => Partial<import('zustand/middleware').PersistOptions<import('../types').CoreAuthStore<CoreUser>, {
             user: CoreUser | null;
-            token: string | null;
-            refreshToken: string | null;
             isAuthenticated: boolean;
         }>>;
     };

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

@@ -1,4 +1,4 @@
-import { BaseApiResponse } from '../../../types';
+import { BaseApiResponse, CoreActions } from '../../../types';
 import { BaseStore } from '../../../types/BaseStore';
 import { BaseType } from '../../../types/BaseType';
 export interface CoreUser extends BaseType {
@@ -17,21 +17,21 @@ export interface CoreRegisterCredentials extends CoreLoginCredentials {
 }
 export interface CoreAuthStore<T extends CoreUser> extends BaseStore {
     user: T | null;
-    token: string | null;
-    refreshToken: string | null;
     isAuthenticated: boolean;
-    getUser: () => Promise<T>;
+    getUser: () => Promise<BaseApiResponse<CoreGetUserResponse<T>>>;
     login: <K extends CoreLoginCredentials>(credentials: K) => Promise<BaseApiResponse<CoreAuthLoginResponse<T>>>;
     register: <K extends CoreRegisterCredentials>(credentials: K) => Promise<BaseApiResponse<CoreAuthRegisterResponse<T>>>;
     logout: () => void;
     refreshUserToken: () => Promise<any>;
     setUser: (user: T | null) => void;
-    setToken: (token: string | null) => void;
-    setRefreshToken: (token: string | null) => void;
+    updateUser: (userId: Pick<T, "id">, updateUserData: Partial<T>, actions?: CoreActions) => void;
+    deleteUser: (userId: Pick<T, "id">, actions?: CoreActions) => void;
 }
 export interface CoreAuthLoginResponse<T extends CoreUser> {
     user: T;
-    token: string;
 }
 export interface CoreAuthRegisterResponse<T extends CoreUser> extends CoreAuthLoginResponse<T> {
 }
+export interface CoreGetUserResponse<T extends CoreUser> {
+    user: T;
+}

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

@@ -3,7 +3,7 @@ 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' | 'loading' | 'error'>;
+    protected initialState: Pick<CoreOrderStore<T>, 'order' | 'orders' | 'loading' | 'error'>;
     constructor(orderService?: CoreOrderBaseService, initialState?: any);
     build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreOrderStore<T>>, "persist"> & {
         persist: {

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

@@ -1,6 +1,6 @@
 import { BaseType } from '../../../types/BaseType';
 import { IOrderActions } from './interfaces/OrderActions';
-import { BaseStore } from '../../../types';
+import { BasePagination, BaseStore } from '../../../types';
 /**
  * CoreOrder base type
 */
@@ -31,6 +31,7 @@ export interface CoreOrder<T> extends BaseType {
 }
 export interface CoreOrderStore<T> extends BaseStore, IOrderActions<T> {
     order: CoreOrder<T>;
+    orders: BasePagination<CoreOrder<T>> | null;
 }
 export interface CoreOrderForm extends BaseType {
     customer_name: string;

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

@@ -1,10 +1,11 @@
 import { AxiosResponse } from 'axios';
-import { BaseApiResponse } from '../../../../types/contracts/BaseApiResponse';
+import { BaseApiResponse, BaseApiResponsePagination } 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>;
+    fetchOrders: (params?: any) => Promise<BaseApiResponsePagination<CoreOrder<T>>>;
 }
 export interface IOrderActionsService<T> {
     createOrder: (order: CoreOrderForm) => Promise<AxiosResponse<BaseApiResponse<CreateOrderResponse<CoreOrder<T>>>>>;

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

@@ -10,7 +10,7 @@ export declare class CoreProductBuilder implements CoreBuilder {
         persist: {
             setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreProductStore<CoreProduct, CoreProductCategory>, {
                 productDetails: CoreProduct | null;
-                products: import('../../..').BasePagination<CoreProduct> | null;
+                products: import('../../../types').BasePagination<CoreProduct> | null;
                 categories: CoreProductCategory[] | null;
             }>>) => void;
             clearStorage: () => void;
@@ -20,7 +20,7 @@ export declare class CoreProductBuilder implements CoreBuilder {
             onFinishHydration: (fn: (state: CoreProductStore<CoreProduct, CoreProductCategory>) => void) => () => void;
             getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreProductStore<CoreProduct, CoreProductCategory>, {
                 productDetails: CoreProduct | null;
-                products: import('../../..').BasePagination<CoreProduct> | null;
+                products: import('../../../types').BasePagination<CoreProduct> | null;
                 categories: CoreProductCategory[] | null;
             }>>;
         };

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

@@ -6,6 +6,7 @@ import { BaseSlugType } from '../../../types/interfaces/BaseSlugType';
 import { BaseVisibleType } from '../../../types/interfaces/BaseVisibleType';
 import { CoreProductCategory, HasProductCategories } from './CoreProductCategory';
 import { BaseApiResponse, BaseApiResponsePagination } from '../../../types/contracts/BaseApiResponse';
+import { CoreActions } from '../../../types';
 /**
  * CoreProduct base type
 */
@@ -28,7 +29,7 @@ export interface CoreProductStore<T extends CoreProduct, K extends CoreProductCa
     setProducts: (products: BasePagination<T> | null) => void;
     setCategories: (categories: K[]) => void;
     setProductDetails: (product: T | null) => void;
-    fetchProducts: (params?: Record<string, any>) => Promise<BaseApiResponsePagination<T>>;
+    fetchProducts: (params?: Record<string, any>, actions?: CoreActions) => Promise<BaseApiResponsePagination<T>>;
     getProducts: () => BasePagination<T> | null;
     fetchProductDetails: (id: string | number) => Promise<BaseApiResponse<T>>;
     getProductDetails: () => T | null;
@@ -44,3 +45,9 @@ export interface CoreProductible extends BaseType {
     base_price_per_unit_in_cents: number;
     base_total_in_cents: number;
 }
+export interface GetProductsResponse<T extends CoreProduct> extends BaseApiResponsePagination<T> {
+    metadata: {
+        min_price: number;
+        max_price: number;
+    };
+}

package/dist/modules/CoreShipment/classes/CoreShipmentBuilder.d.ts

@@ -1,24 +1,26 @@
 import { CoreBuilder } from '../../../classes/CoreBuilder';
 import { CoreShipmentBaseService } from '../services/base';
-import { CoreShippingAddress, CoreShipmentStore, CoreShippingMethod, CoreShippingMethodTypes } from '../types/CoreShipment';
-export declare class CoreShipmentBuilder<T extends CoreShippingMethod<Z>, K extends CoreShippingAddress, Z extends CoreShippingMethodTypes> implements CoreBuilder {
-    protected shipmentService: CoreShipmentBaseService<T, K, Z>;
-    protected initialState: Pick<CoreShipmentStore<T, K, Z>, "shippingMethods" | "shippingAddresses" | "loading" | "error">;
-    constructor(service?: CoreShipmentBaseService<T, K, Z>, initialState?: any);
-    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreShipmentStore<T, K, Z>>, "persist"> & {
+import { CoreShippingAddress, CoreShipmentStore, CoreShippingMethod, CoreShippingMethodTypes, CoreShipmentBeneficiary } from '../types/CoreShipment';
+export declare class CoreShipmentBuilder<T extends CoreShippingMethod<Z>, K extends CoreShippingAddress, Z extends CoreShippingMethodTypes, Y extends CoreShipmentBeneficiary> implements CoreBuilder {
+    protected shipmentService: CoreShipmentBaseService<T, K, Z, Y>;
+    protected initialState: Pick<CoreShipmentStore<T, K, Z, Y>, "shippingMethods" | "shippingAddresses" | "beneficiaries" | "loading" | "error">;
+    constructor(service?: CoreShipmentBaseService<T, K, Z, Y>, initialState?: any);
+    build(): import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CoreShipmentStore<T, K, Z, Y>>, "persist"> & {
         persist: {
-            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreShipmentStore<T, K, Z>, {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CoreShipmentStore<T, K, Z, Y>, {
                 shippingMethods: T[] | null;
-                shippingAddresses: import('../../..').BasePagination<K> | null;
+                shippingAddresses: import('../../../types').BasePagination<K> | null;
+                beneficiaries: import('../../../types').BasePagination<Y> | null;
             }>>) => void;
             clearStorage: () => void;
             rehydrate: () => Promise<void> | void;
             hasHydrated: () => boolean;
-            onHydrate: (fn: (state: CoreShipmentStore<T, K, Z>) => void) => () => void;
-            onFinishHydration: (fn: (state: CoreShipmentStore<T, K, Z>) => void) => () => void;
-            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreShipmentStore<T, K, Z>, {
+            onHydrate: (fn: (state: CoreShipmentStore<T, K, Z, Y>) => void) => () => void;
+            onFinishHydration: (fn: (state: CoreShipmentStore<T, K, Z, Y>) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<CoreShipmentStore<T, K, Z, Y>, {
                 shippingMethods: T[] | null;
-                shippingAddresses: import('../../..').BasePagination<K> | null;
+                shippingAddresses: import('../../../types').BasePagination<K> | null;
+                beneficiaries: import('../../../types').BasePagination<Y> | null;
             }>>;
         };
     }>;

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

@@ -1,13 +1,18 @@
 import { BaseService } from '../../../services/base';
-import { CoreShippingAddress, CoreShippingAddressForm, CoreShippingMethod, CoreShippingMethodTypes } from '../types/CoreShipment';
+import { CoreShipmentBeneficiary, CoreShipmentBeneficiaryForm, CoreShippingAddress, CoreShippingAddressForm, CoreShippingMethod, CoreShippingMethodTypes } from '../types/CoreShipment';
 import { BaseApiResponse, BaseApiResponsePagination } from '../../../types';
 /**
  * Base class that can be extended by concrete services
 */
-export declare class CoreShipmentBaseService<T extends CoreShippingMethod<Z>, K extends CoreShippingAddress, Z extends CoreShippingMethodTypes> extends BaseService {
+export declare class CoreShipmentBaseService<T extends CoreShippingMethod<Z>, K extends CoreShippingAddress, Z extends CoreShippingMethodTypes, Y extends CoreShipmentBeneficiary> extends BaseService {
     constructor();
     getShippingMethods(): Promise<import('axios').AxiosResponse<BaseApiResponse<T[]>, any>>;
     getShippingAddresses(params?: Record<string, any>): Promise<import('axios').AxiosResponse<BaseApiResponsePagination<K>, any>>;
     addShippingAddress<T extends CoreShippingAddressForm>(newAddress: T): Promise<import('axios').AxiosResponse<BaseApiResponse<K>, any>>;
     updateShippingAddress(addressId: Pick<K, 'id'>, updateAddress: Partial<K>): Promise<import('axios').AxiosResponse<BaseApiResponse<K>, any>>;
+    deleteShippingAddress: (addressId: Pick<K, "id">) => Promise<import('axios').AxiosResponse<BaseApiResponse<null>, any>>;
+    getBeneficiaries: (params?: Record<string, any>) => Promise<import('axios').AxiosResponse<BaseApiResponsePagination<Y>, any>>;
+    addBeneficiary<X extends CoreShipmentBeneficiaryForm>(newBeneficiary: X): Promise<import('axios').AxiosResponse<BaseApiResponse<Y>, any>>;
+    updateBeneficiary<X extends CoreShipmentBeneficiaryForm>(beneficiaryId: Pick<Y, 'id'>, updateBeneficiary: X): Promise<import('axios').AxiosResponse<BaseApiResponse<Y>, any>>;
+    deleteBeneficiary(beneficiaryId: Pick<Y, 'id'>): Promise<import('axios').AxiosResponse<BaseApiResponse<null>, any>>;
 }

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

@@ -1,15 +1,22 @@
-import { BaseApiResponse, BaseApiResponsePagination, BasePagination, BaseStore } from '../../../types';
+import { BaseApiResponse, BaseApiResponsePagination, BasePagination, BaseStore, CoreActions } from '../../../types';
 import { BaseType } from '../../../types/BaseType';
-export interface CoreShipmentStore<T extends CoreShippingMethod<Z>, K extends CoreShippingAddress, Z extends CoreShippingMethodTypes> extends BaseStore {
+export interface CoreShipmentStore<T extends CoreShippingMethod<Z>, K extends CoreShippingAddress, Z extends CoreShippingMethodTypes, Y extends CoreShipmentBeneficiary> extends BaseStore {
     shippingMethods: T[] | null;
     shippingAddresses: BasePagination<K> | null;
+    beneficiaries: BasePagination<Y> | null;
     setShippingMethods: (shippingMethods: T[] | null) => void;
     getShippingMethods: () => T[] | null;
     fetchShippingMethods: () => Promise<BaseApiResponse<T[]>>;
     setShippingAddresses: (shippingAddresses: BasePagination<K> | null) => void;
     getShippingAddresses: () => BasePagination<K> | null;
-    fetchShippingAddresses: (params?: Record<string, any>) => Promise<BaseApiResponsePagination<K>>;
-    addShippingAddress: (newAddress: K) => void;
+    fetchShippingAddresses: (params?: Record<string, any>, actions?: CoreActions) => Promise<BaseApiResponsePagination<K>>;
+    addShippingAddress: <X extends CoreShippingAddressForm>(newAddress: X, params?: Record<string, any>, actions?: CoreActions) => void;
+    updateShippingAddress: (addressId: Pick<K, 'id'>, updateAddress: Partial<K>, params?: Record<string, any>, actions?: CoreActions) => void;
+    deleteShippingAddress: (addressId: Pick<K, 'id'>, params?: Record<string, any>, actions?: CoreActions) => void;
+    fetchBeneficiaries: (params?: Record<string, any>, actions?: CoreActions) => Promise<BaseApiResponsePagination<Y>>;
+    addBeneficiary: <X extends CoreShipmentBeneficiaryForm>(newBeneficiary: X, params?: Record<string, any>, actions?: CoreActions) => void;
+    updateBeneficiary: (beneficiaryId: Pick<Y, 'id'>, updateBeneficiary: CoreShipmentBeneficiaryForm, params?: Record<string, any>, actions?: CoreActions) => void;
+    deleteBeneficiary: (beneficiaryId: Pick<Y, 'id'>, params?: Record<string, any>, actions?: CoreActions) => void;
 }
 export interface CoreShippingMethod<T extends CoreShippingMethodTypes> extends BaseType {
     name: string;
@@ -39,7 +46,7 @@ export interface CoreShippingAddress extends BaseType {
 export interface CoreShippingAddressLocalPickup extends CoreShippingAddress {
 }
 export interface CoreShippingAddressHomeDelivery extends CoreShippingAddress {
-    label: string;
+    label?: string;
     is_default: boolean;
 }
 export interface CoreShippingAddressProvinceMunicipality extends CoreShippingAddressHomeDelivery {
@@ -57,3 +64,15 @@ export interface CoreShippingAddressProvinceMunicipalityForm extends CoreShippin
     province: string;
     municipality: string;
 }
+export interface CoreShipmentBeneficiary extends BaseType {
+    name: string;
+    email: string;
+    phone: string;
+    is_default: boolean;
+}
+export interface CoreShipmentBeneficiaryForm {
+    name: string;
+    email: string;
+    phone: string;
+    is_default: boolean;
+}

package/dist/types/ui/template.d.ts

@@ -19,6 +19,7 @@ export interface CoreDesignTemplateSettings {
     store_map_iframe: string;
     available_coins: CoreDesignTemplateCoin[];
     base_coin: CoreDesignTemplateCoin;
+    store_about_us: string;
 }
 export interface CoreDesignTemplateCoin {
     short_name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ingeniuscliq-core",
-  "version": "0.3.48",
+  "version": "0.4.1",
   "description": "IngeniusCliq Core UI y lógica compartida",
   "license": "MIT",
   "type": "module",