@soma-vertical-web/multi-lib 0.0.26 → 0.0.28

package/contexts/contexts/GlobalContext.d.ts

@@ -7,6 +7,6 @@ export declare class Mediator {
     publish<T>(event: string, data: T): void;
 }
 declare const GlobalContext: import('react').Context<GlobalContextProps>;
-declare const GlobalProvider: ({ children, headerConfigs, pathname, searchParams, ...props }: GlobalProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const GlobalProvider: ({ children, headerConfigs, pathname, ...props }: GlobalProviderProps) => import("react/jsx-runtime").JSX.Element;
 declare const useGlobalContext: () => GlobalContextProps;
 export { GlobalContext, GlobalProvider, useGlobalContext };

package/contexts/index.d.ts

@@ -47,7 +47,7 @@ export declare const contexts: {
         };
         global: {
             hook: () => import('../types/contexts/contexts/global').GlobalContextProps;
-            provider: ({ children, headerConfigs, pathname, searchParams, ...props }: import('../types/contexts/contexts/global').GlobalProviderProps) => import("react/jsx-runtime").JSX.Element;
+            provider: ({ children, headerConfigs, pathname, ...props }: import('../types/contexts/contexts/global').GlobalProviderProps) => import("react/jsx-runtime").JSX.Element;
             mediator: typeof Mediator;
         };
         header: {

package/data/api/checkout/address/index.d.ts

@@ -0,0 +1,21 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+export declare const schemaAddress: yup.ObjectSchema<{
+    country: string;
+    postalCode: string | null | undefined;
+}, yup.AnyObject, {
+    country: undefined;
+    postalCode: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaAddress>;
+/**
+ * This endpoint retrieves address information for a given postal code and country.
+ * https://developers.vtex.com/docs/api-reference/checkout-api?endpoint=get-/api/checkout/pub/postal-code/-countryCode-/-postalCode-
+ *
+ * @param req The Next.js API request object.
+ * @param res The Next.js API response object.
+ * @returns Address information corresponding to the provided postal code and country.
+ * This request is useful for implementing auto-complete functionality when a customer needs to fill in an address.
+ */
+export declare function postOrderformAddress({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/index.d.ts

@@ -0,0 +1,4 @@
+export * from './address';
+export * from './order-form';
+export * from './region';
+export * from './simulation';

package/data/api/checkout/order-form/attachments/index.d.ts

@@ -0,0 +1,17 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+export declare const schemaAttachments: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    sellerCode: string | null | undefined;
+    sellerName: string | null | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    sellerCode: undefined;
+    sellerName: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaAttachments>;
+/**
+ * Attach marketing and open text field data to a shopping cart.
+ */
+export declare function postOrderFormAttachOrderFormData({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/attachments/marketing-data/index.d.ts

@@ -0,0 +1,21 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaMarketingData: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    sellerCode: string | null | undefined;
+    marketingData: {};
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    sellerCode: undefined;
+    marketingData: {};
+}, "">;
+type SchemaType = yup.InferType<typeof schemaMarketingData>;
+/**
+ * Use this request to include marketing information to a given shopping cart.
+ * https://developers.vtex.com/docs/api-reference/checkout-api#post-/api/checkout/pub/orderForm/-orderFormId-/attachments/marketingData
+ *
+ * @returns A list of sellers that cater to the specified region or address.
+ * This endpoint provides flexibility in accessing seller information based on region or address, allowing you to choose between path parameters or query parameters.
+ */
+export declare function postOrderFormAttachmentsMarketingData({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/attachments/open-text-field/index.d.ts

@@ -0,0 +1,18 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaOpenTextField: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    sellerCode: string | null | undefined;
+    sellerName: string | null | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    sellerCode: undefined;
+    sellerName: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaOpenTextField>;
+/**
+ * Use this request to include open text field information to a given shopping cart.
+ * https://developers.vtex.com/docs/api-reference/checkout-api#post-/api/checkout/pub/orderForm/-orderFormId-/attachments/openTextField
+ */
+export declare function postOrderFormAttachmentsOpenTextField({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/coupon/index.d.ts

@@ -0,0 +1,15 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaCoupon: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    coupon: string | null | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    coupon: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaCoupon>;
+/**
+ * Add a coupon to a given shopping cart.
+ */
+export declare function postOrderFormAddCoupon({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/custom-data/index.d.ts

@@ -0,0 +1,17 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaCustomData: yup.ObjectSchema<{
+    appId: string;
+    orderFormId: string | null | undefined;
+    key: (string | undefined)[] | undefined;
+}, yup.AnyObject, {
+    appId: undefined;
+    orderFormId: undefined;
+    key: "";
+}, "">;
+type SchemaType = yup.InferType<typeof schemaCustomData>;
+/**
+ * Update custom data for an order form app.
+ */
+export declare function putOrderFormCustomData({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/index.d.ts

@@ -0,0 +1,14 @@
+export * from './attachments';
+export * from './attachments/marketing-data';
+export * from './attachments/open-text-field';
+export * from './coupon';
+export * from './custom-data';
+export * from './items/remove-all';
+export * from './items/update';
+export * from './messages/remove-all';
+export * from './offerings';
+export * from './orderform';
+export * from './profile';
+export * from './seller-code';
+export * from './shipping';
+export * from './shipping/update';

package/data/api/checkout/order-form/items/remove-all/index.d.ts

@@ -0,0 +1,13 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaItems: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaItems>;
+/**
+ * Remove all items from the shopping cart.
+ */
+export declare function postOrderFormRemoveAllItems({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/items/update/index.d.ts

@@ -0,0 +1,43 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+export declare const schemaItem: yup.ObjectSchema<{
+    attachments: {
+        name: string;
+        content: {} | null;
+    }[] | null | undefined;
+    id: string;
+    index: number | null | undefined;
+    quantity: number | null | undefined;
+    seller: string;
+    price: number | undefined;
+}, yup.AnyObject, {
+    attachments: "";
+    id: undefined;
+    index: undefined;
+    quantity: undefined;
+    seller: undefined;
+    price: undefined;
+}, "">;
+declare const schemaItems: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    orderItems: {
+        quantity?: number | null | undefined;
+        price?: number | undefined;
+        index?: number | null | undefined;
+        attachments?: {
+            name: string;
+            content: {} | null;
+        }[] | null | undefined;
+        seller: string;
+        id: string;
+    }[] | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    orderItems: "";
+}, "">;
+type SchemaType = yup.InferType<typeof schemaItems>;
+/**
+ * Update items in the shopping cart.
+ */
+export declare function postOrderFormUpdateItems({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/messages/remove-all/index.d.ts

@@ -0,0 +1,13 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaMessage: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaMessage>;
+/**
+ * Remove all messages from the orderForm messages field.
+ */
+export declare function postOrderFormClearMessages({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/offerings/index.d.ts

@@ -0,0 +1,19 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaOffering: yup.ObjectSchema<{
+    id: string | null | undefined;
+    itemIndex: number | null | undefined;
+    orderFormId: string | null | undefined;
+    remove: boolean | null | undefined;
+}, yup.AnyObject, {
+    id: undefined;
+    itemIndex: undefined;
+    orderFormId: undefined;
+    remove: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaOffering>;
+/**
+ * Add or remove a service (offering) to a specific item in the shopping cart.
+ */
+export declare function updateOrderFormOffering({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/orderform/index.d.ts

@@ -0,0 +1,14 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaOrderForm: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaOrderForm>;
+/**
+ * Retrieves all information associated with a given shopping cart.
+ * https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/orderForm/-orderFormId-
+ */
+export declare function getOrderForm({ apiUrl, body, fetchOptions, extraData, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/profile/index.d.ts

@@ -0,0 +1,25 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaProfile: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    email: string;
+    firstName: string;
+    lastName: string;
+    documentType: string;
+    document: string;
+    phone: string | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    email: undefined;
+    firstName: undefined;
+    lastName: undefined;
+    documentType: undefined;
+    document: undefined;
+    phone: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaProfile>;
+/**
+ * Attach client profile data to a shopping cart.
+ */
+export declare function postOrderFormAttachClientProfileData({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/seller-code/index.d.ts

@@ -0,0 +1,13 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaSellerCode: yup.ObjectSchema<{
+    sellerCode: string | null | undefined;
+}, yup.AnyObject, {
+    sellerCode: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaSellerCode>;
+/**
+ * Fetch seller code data from VTEX data entities.
+ */
+export declare function getMasterDataSellerCode({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/shipping/index.d.ts

@@ -0,0 +1,17 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaShipping: yup.ObjectSchema<{
+    country: string;
+    orderFormId: string | null | undefined;
+    postalCode: string | null | undefined;
+}, yup.AnyObject, {
+    country: undefined;
+    orderFormId: undefined;
+    postalCode: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schemaShipping>;
+/**
+ * Attach shipping data to a shopping cart.
+ */
+export declare function postOrderFormAttachShippingData({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/order-form/shipping/update/index.d.ts

@@ -0,0 +1,36 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaShipping: yup.ObjectSchema<{
+    orderFormId: string | null | undefined;
+    options: {
+        itemIndex?: number | undefined;
+        selectedDeliveryChannel?: string | undefined;
+        selectedSla?: string | undefined;
+    }[] | undefined;
+    selectedAddresses: {
+        number?: string | null | undefined;
+        state?: string | null | undefined;
+        city?: string | null | undefined;
+        complement?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        receiverName?: string | null | undefined;
+        reference?: string | null | undefined;
+        street?: string | null | undefined;
+        country: string;
+        postalCode: string;
+        addressId: string;
+        addressType: string;
+        geoCoordinates: (number | undefined)[];
+        isDisposable: NonNullable<boolean | undefined>;
+    }[] | undefined;
+}, yup.AnyObject, {
+    orderFormId: undefined;
+    options: "";
+    selectedAddresses: "";
+}, "">;
+type SchemaType = yup.InferType<typeof schemaShipping>;
+/**
+ * Attach shipping data with options and addresses to a shopping cart.
+ */
+export declare function postOrderFormUpdateShippingData({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/region/index.d.ts

@@ -0,0 +1,33 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaRegion: yup.ObjectSchema<{
+    country: string;
+    postalCode: string | null | undefined;
+    geoCoordinates: {
+        longitude: number;
+        latitude: number;
+    };
+}, yup.AnyObject, {
+    country: undefined;
+    postalCode: undefined;
+    geoCoordinates: {
+        longitude: undefined;
+        latitude: undefined;
+    };
+}, "">;
+type SchemaType = yup.InferType<typeof schemaRegion>;
+/**
+ * Retrieves a list of sellers that cater to a specific region or address, according to your setup of our regionalization feature.
+ * https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/regions/-regionId-
+ *
+ * To access the list of sellers, you must choose one of the following methods:
+ * 1. Send the identification of the list of sellers (regionId) as a path parameter through the URL.
+ * 2. Send the country (3-digit ISO code) and at least one of the two values (postal Code or geo Coordinates) as query parameters through the URL.
+ * For this method, it is also allowed to send both values (postalCode or geoCoordinates) in the same request.
+ *
+ * @param regionId.
+ * @returns A list of sellers that cater to the specified region or address.
+ * This endpoint provides flexibility in accessing seller information based on region or address, allowing you to choose between path parameters or query parameters.
+ */
+export declare function postOrderFormRegion({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/checkout/simulation/index.d.ts

@@ -1,5 +1,21 @@
-import { FetchOptions } from '../../fetchVtex';
-
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaSimulation: yup.ObjectSchema<{
+    items: {
+        seller?: string | undefined;
+        id: string;
+        quantity: number;
+    }[] | undefined;
+    country: string;
+    postalCode: string | null | undefined;
+    geoCoordinates: (number | undefined)[] | null | undefined;
+}, yup.AnyObject, {
+    items: "";
+    country: undefined;
+    postalCode: undefined;
+    geoCoordinates: "";
+}, "">;
+type SchemaType = yup.InferType<typeof schemaSimulation>;
 /**
  * This function performs a request to the API to simulate a cart in VTEX Checkout.
  * https://developers.vtex.com/docs/api-reference/checkout-api#post-/api/checkout/pub/orderForms/simulation
@@ -10,8 +26,5 @@ import { FetchOptions } from '../../fetchVtex';
  * @returns All information about the cart, including selling price of each item, pricing and promotion data, payment and logistics info.
  * This request is useful whenever you need to know the availability of fulfilling an order for a specific cart setting, since the API response will let you know the updated price, inventory, and shipping data.
  */
-export declare function freightSimulation({ apiUrl, body, options }: {
-    apiUrl: string;
-    body: any;
-    options: FetchOptions;
-}): Promise<Record<string, any>>;
+export declare function postOrderFormFreightSimulation({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<Record<string, any>>;
+export {};

package/data/api/fetchVtex.d.ts

@@ -1,11 +1,3 @@
-export interface FetchOptions {
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    body?: Record<string, unknown>;
-    headers?: Record<string, string> & {
-        'REST-Range'?: string;
-        'X-VTEX-API-AppKey'?: string;
-        'X-VTEX-API-AppToken'?: string;
-    };
-    skipSanitize?: boolean;
-}
+import { FetchOptions } from '../../types/data/api';
+
 export declare const fetchVtex: (url: string, options?: FetchOptions) => Promise<Record<string, any>>;

package/data/helpers/cart/index.d.ts

@@ -1,6 +1,6 @@
 import { FetchPriority } from '../../../types/contexts/hooks';
 import { OrderFormItem, OrderForm } from '../../../types/data/api/checkout/order-form';
-import { AddToCart, CartItem, CartItemOptionalProps, CartItemStore, NotificationsStore, OptionalOrderForm } from '../../../types/contexts/store/cart';
+import { AddToCart, CartItem, CartItemOptionalProps, CartItemStore, OrderFormConstants, NotificationsStore, OptionalOrderForm } from '../../../types/contexts/store/cart';
 
 export declare const VALUE_REFERENCES: {
     readonly attachment: "ATTACHMENT";
@@ -39,7 +39,7 @@ export declare const isGift: (price: number) => price is 0;
 export declare const getCategories: (productCategoryIds: string, productCategories: {
     [key: string]: string;
 }) => string[];
-export declare const createItemOrder: (item: OrderFormItem) => CartItemStore;
+export declare const createItemOrder: (item: OrderFormItem, CONSTANTS?: OrderFormConstants) => CartItemStore;
 export declare const addItemOrder: (items: CartItemStore[], item: AddToCart | AddToCart[]) => AddToCart[];
 export declare const removeQuantity: (items: CartItemStore[], id: string) => {
     updateItems: {
@@ -74,7 +74,7 @@ export declare const getTotalizer: (items: CartItemStore[]) => {
     subTotal: number;
 };
 export declare const getTotalItems: (items?: CartItemStore[]) => number;
-export declare const orderFormValues: (orderForm: OrderForm) => {
+export declare const orderFormValues: (orderForm: OrderForm, CONSTANTS?: OrderFormConstants) => {
     id: string;
     itemMetadata: {
         items: import('../../../types/data/api/checkout/order-form').MetadataItem[];
@@ -182,7 +182,7 @@ export declare const mergeOptionsPromise: (res: Promise<Array<CartItemOptionalPr
 export declare const fetchCartAPI: (url: string, params: {
     priority?: FetchPriority;
     body: Record<string, unknown>;
-}, skipSanitize?: boolean) => Promise<any>;
+}, skipSanitize?: boolean, CONSTANTS?: OrderFormConstants) => Promise<any>;
 export declare const addNotification: (state: NotificationsStore, message: string, callback?: () => void) => {
     notifications: import('../../../types/contexts/store/cart').Notification[];
 };