@soma-vertical-web/multi-lib-sacurai 0.0.1

package/data/api/catalog/product/info/index.d.ts

@@ -0,0 +1,10 @@
+import { FetchFunctionsProps } from '../../../../../types/data/api';
+import * as yup from 'yup';
+declare const schema: yup.ObjectSchema<{
+    ids: string[];
+}, yup.AnyObject, {
+    ids: "";
+}, "">;
+type SchemaType = yup.InferType<typeof schema>;
+export declare function getCatalogProducts({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};

package/data/api/catalog/product/similars/index.d.ts

@@ -0,0 +1,3 @@
+import { TEXTURE_IMAGEType } from '../../../../../types/constants';
+
+export declare const getSimilars: (productId: string, TEXTURE_IMAGE: TEXTURE_IMAGEType) => Promise<import('../../../../../types/data/api/catalog/product').SimilarType[]>;

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

@@ -0,0 +1,21 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+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<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';
+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, extraData }: FetchFunctionsProps<SchemaType>): Promise<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, extraData, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<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<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<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<any>;
+export {};

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

@@ -0,0 +1,15 @@
+export * from './attachments';
+export * from './attachments/marketing-data';
+export * from './attachments/open-text-field';
+export * from './coupon';
+export * from './custom-data';
+export * from './items';
+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/index.d.ts

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

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<any>;
+export {};

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

@@ -0,0 +1,25 @@
+import { FetchFunctionsProps } from '../../../../../../types/data/api';
+import * as yup from 'yup';
+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;
+        id: string;
+        seller: 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<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<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<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<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<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, extraData, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<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<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;
+        street?: string | null | undefined;
+        city?: string | null | undefined;
+        complement?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        receiverName?: string | null | undefined;
+        reference?: 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<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: {
+        latitude: number;
+        longitude: 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<any>;
+export {};

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

@@ -0,0 +1,30 @@
+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
+ *
+ * @param skuId The SKU ID.
+ * @param quantity The quantity of items in the cart.
+ * @param sellerId The seller ID.
+ * @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 postOrderFormFreightSimulation({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};

package/data/api/cms/content-type/index.d.ts

@@ -0,0 +1,3 @@
+import { GetCMSContentTypeProps } from '../../../../types/data/api/cms';
+
+export declare function getCMSContentType({ contentType, documentId, versionId, storeId, CMS_PROJECT_NAME, }: GetCMSContentTypeProps): Promise<Response>;

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

@@ -0,0 +1,12 @@
+/**
+ * fetch content type CMS
+ *
+ * @param {string} contentType - The type of content to fetch from Strapi.
+ * @param {string} params - Query parameters to append to the API request.
+ * @return {Promise<object>} The fetched data.
+ */
+export declare function fetchContentType<T>(contentType: string, params?: Record<string, unknown>, spreadData?: boolean): Promise<{
+    status: number | string;
+    data: T[] | T | null;
+}>;
+export * from './content-type';

package/data/api/fetchVtex.d.ts

@@ -0,0 +1,5 @@
+import { FetchOptions } from '../../types/data/api';
+
+export declare const fetchVtex: (url: string, options?: FetchOptions) => Promise<any>;
+export declare const fetchVtexOrderForm: (url: string, options?: FetchOptions) => Promise<Record<string, any>>;
+export declare function fetchVtexWithAbortController<T>(url: string, options?: FetchOptions): Promise<T | undefined>;

package/data/api/master-data/index.d.ts

@@ -0,0 +1,3 @@
+export * from './masterdata';
+export * from './search';
+export * from './update';

package/data/api/master-data/masterdata/index.d.ts

@@ -0,0 +1,26 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaMasterData: yup.ObjectSchema<{
+    masterDataEntity: string | undefined;
+    payload: {} | null;
+}, yup.AnyObject, {
+    masterDataEntity: undefined;
+    payload: {};
+}, "">;
+type SchemaType = yup.InferType<typeof schemaMasterData>;
+/**
+ * Updates existing documents within a specified data entity.
+ * [https://developers.vtex.com/docs/api-reference/master-data-api-v2#patch-/api/dataentities/-dataEntityName-/documents?endpoint=patch-/api/dataentities/-dataEntityName-/documents](https://developers.vtex.com/docs/api-reference/master-data-api-v2#patch-/api/dataentities/-dataEntityName-/documents?endpoint=patch-/api/dataentities/-dataEntityName-/documents)
+ *
+ * The data entity (dataEntityName) is a collection of documents, similar to a database table,
+ * and the documents are the individual records within that collection.
+ *
+ * @param dataEntityName The name of the data entity containing the documents to be updated.
+ * @param documents An array of objects, where each object represents a document to be updated. Each object must contain the 'id' field to identify the document.
+ * @returns This request allows updating existing documents within a specified data entity.
+ * The dataEntityName parameter specifies the data entity where the documents will be updated.
+ * The documents array allows you to update multiple documents in a single request.
+ * Each document must contain the 'id' to identify the document to be updated, and the fields you want to modify.
+ */
+export declare function postMasterdata({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};

package/data/api/master-data/search/index.d.ts

@@ -0,0 +1,61 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const searchFieldsSchema: yup.ObjectSchema<{
+    _where: string | undefined;
+    _fields: string | undefined;
+    _sort: string | undefined;
+    _from: number | undefined;
+    _to: number | undefined;
+    _keyword: string | undefined;
+}, yup.AnyObject, {
+    _where: undefined;
+    _fields: undefined;
+    _sort: undefined;
+    _from: undefined;
+    _to: undefined;
+    _keyword: undefined;
+}, "">;
+declare const schemaMasterData: yup.ObjectSchema<{
+    masterDataEntity: string;
+    searchFields: {
+        _where?: string | undefined;
+        _fields?: string | undefined;
+        _sort?: string | undefined;
+        _from?: number | undefined;
+        _to?: number | undefined;
+        _keyword?: string | undefined;
+    };
+    headers: {
+        "REST-Range"?: yup.Maybe<string | undefined>;
+    };
+}, yup.AnyObject, {
+    masterDataEntity: undefined;
+    searchFields: {
+        _where: undefined;
+        _fields: undefined;
+        _sort: undefined;
+        _from: undefined;
+        _to: undefined;
+        _keyword: undefined;
+    };
+    headers: {
+        'REST-Range': undefined;
+    };
+}, "">;
+type SchemaType = yup.InferType<typeof schemaMasterData>;
+export type SearchFieldsMasterData = yup.InferType<typeof searchFieldsSchema>;
+/**
+ * Searches for documents within a specified data entity based on provided query parameters.
+ * [https://developers.vtex.com/docs/api-reference/master-data-api-v2#get-/api/dataentities/-dataEntityName-/search?endpoint=get-/api/dataentities/-dataEntityName-/search](https://developers.vtex.com/docs/api-reference/master-data-api-v2#get-/api/dataentities/-dataEntityName-/search?endpoint=get-/api/dataentities/-dataEntityName-/search)
+ *
+ * The data entity (dataEntityName) is a collection of documents, similar to a database table,
+ * and this endpoint allows searching for documents within that collection.
+ *
+ * @param dataEntityName The name of the data entity to search within.
+ * @param queryParams An object containing query parameters to filter the search.
+ * @returns This request allows searching for documents within a specified data entity using query parameters.
+ * The dataEntityName parameter specifies the data entity to search.
+ * The queryParams object allows you to filter the search based on various criteria.
+ */
+export declare function getSearchMasterdata({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};

package/data/api/master-data/update/index.d.ts

@@ -0,0 +1,29 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schemaMasterData: yup.ObjectSchema<{
+    dataEntityName: string;
+    id: string;
+    fieldsToBeUpdated: {};
+}, yup.AnyObject, {
+    dataEntityName: undefined;
+    id: undefined;
+    fieldsToBeUpdated: {};
+}, "">;
+type SchemaType = yup.InferType<typeof schemaMasterData>;
+/**
+ * Updates an existing document within a specified data entity, identified by its ID.
+ * [https://developers.vtex.com/docs/api-reference/master-data-api-v2#patch-/api/dataentities/-dataEntityName-/documents/-id-?endpoint=patch-/api/dataentities/-dataEntityName-/documents/-id-](https://developers.vtex.com/docs/api-reference/master-data-api-v2#patch-/api/dataentities/-dataEntityName-/documents/-id-?endpoint=patch-/api/dataentities/-dataEntityName-/documents/-id-)
+ *
+ * The data entity (dataEntityName) is a collection of documents, similar to a database table,
+ * and the documents are the individual records within that collection.
+ *
+ * @param dataEntityName The name of the data entity containing the document to be updated.
+ * @param id The unique identifier of the document to be updated.
+ * @param document An object representing the document with the fields to be updated.
+ * @returns This request allows updating an existing document within a specified data entity using its ID.
+ * The dataEntityName parameter specifies the data entity where the document will be updated.
+ * The id parameter specifies the unique identifier of the document to be updated.
+ * The document object contains the fields and their updated values.
+ */
+export declare function patchUpdateMasterdata({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};

package/data/api/search/autoCompleteSuggestions/index.d.ts

@@ -0,0 +1,11 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+
+import * as yup from 'yup';
+declare const schema: yup.ObjectSchema<{
+    query: string | undefined;
+}, yup.AnyObject, {
+    query: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schema>;
+export declare function getSearchAutoCompleteSuggestions({ apiUrl, body, fetchOptions, }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};