@scayle/storefront-nuxt 8.10.4 → 8.11.1

package/dist/runtime/composables/storefront/useBrand.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves brand data using the `getBrandById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching brand data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/brands/get-a-brand
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getBrandById'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getBrandById` RPC call.
+ * @param params.params The parameters for the `getBrandById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useBrand<DataT = NormalizedRpcResponse<'getBrandById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrandById'>>;
     options: UseRpcOptions<'getBrandById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useBrands.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves multiple brands data using the 'getBrands' RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching brands data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/brands/list-brands
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getBrands'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getBrands` RPC call.
+ * @param params.params The parameters for the `getBrands` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. This key is used internally by `useRpc` for caching and managing state.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useBrands<DataT = NormalizedRpcResponse<'getBrands'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrands'>>;
     options: UseRpcOptions<'getBrands', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCategories.d.ts

@@ -4,6 +4,34 @@ import type { MaybeRefOrGetter } from 'vue';
 type UseCategoriesBaseReturn<DataT, PickKeys extends KeysOf<DataT>, DefaultT> = Pick<Awaited<UseRpcReturn<'getCategoriesByPath', DataT, PickKeys, DefaultT>>, 'data' | 'error' | 'status' | 'refresh'> & {
     getCategoryById: (id: number, includeHidden?: true) => RpcMethodReturnType<'getCategoryById'>;
 };
+/**
+ * Retrieves categories data using the 'getCategoriesByPath' RPC method and
+ * provides a helper for fetching individual categories by ID.
+ *
+ * This function extends the functionality of `useRpc` by adding a
+ * `getCategoryById` method to the returned object. It fetches category data via
+ * 'getCategoriesByPath', then constructs and returns a promise enriched with the data,
+ * error, status, refresh function from the original promise, along with the
+ * added `getCategoryById` function. This approach allows for efficient retrieval
+ * of category data and simplifies the process of accessing individual categories.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching brand data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getCategoriesByPath'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param input An object containing parameters and options for the `getCategoriesByPath` RPC call.
+ * @param input.params The parameters for the `getCategoriesByPath` RPC method.
+ * @param input.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param keyA A unique key for caching and state management within `useRpc`.
+ *
+ * @returns A promise that resolves to an object containing the category data,
+ *          error and status information, a refresh function, and a `getCategoryById`
+ *          function for fetching individual categories.
+ */
 export declare function useCategories<DataT = NormalizedRpcResponse<'getCategoriesByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoriesByPath'>>;
     options: UseRpcOptions<'getCategoriesByPath', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCategoryById.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data for a single category by its ID using the `getCategoryById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/categories/get-a-category
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getCategoryById'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getCategoryById` RPC call.
+ * @param params.params The parameters for the `getCategoryById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useCategoryById<DataT = NormalizedRpcResponse<'getCategoryById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryById'>>;
     options: UseRpcOptions<'getCategoryById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCategoryByPath.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data for a single category by its path using the `getCategoryByPath` RPC method.
+ *
+ *  This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/categories/get-a-category
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getCategoriesByPath'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getCategoryByPath` RPC call.
+ * @param params.params The parameters for the `getCategoryByPath` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useCategoryByPath<DataT = NormalizedRpcResponse<'getCategoryByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }: {
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryByPath'>>;
     options?: UseRpcOptions<'getCategoryByPath', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCurrentPromotions.d.ts

@@ -1,6 +1,30 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data of the current active promotion data using the `getCurrentPromotions` RPC method.
+ *
+ *  This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options, and it uses the default shared cache
+ * implementation, getting data from Nuxt's payload or static data during hydration
+ * or from async data otherwise.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/promotions/list-promotions
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#managing-shared-state-with-userpc
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getCurrentPromotions'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getCurrentPromotions` RPC call.
+ * @param params.params The parameters for the `getCurrentPromotions` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useCurrentPromotions<DataT = NormalizedRpcResponse<'getCurrentPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCurrentPromotions'>>;
     options: UseRpcOptions<'getCurrentPromotions', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useFilters.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves filter data using the `getFilters` RPC method.
+ *
+ *  This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/filters/list-filters
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getFilters'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getFilters` RPC call.
+ * @param params.params The parameters for the `getFilters` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useFilters<DataT = NormalizedRpcResponse<'getFilters'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getFilters'>>;
     options: UseRpcOptions<'getFilters', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useNavigationTree.d.ts

@@ -1,10 +1,52 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data of a single navigation tree using the `fetchNavigationTreeById` RPC method.
+ *
+ *  This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/navigation/get-a-navigation
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getBrands'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `fetchNavigationTreeById` RPC call.
+ * @param params.params The parameters for the `fetchNavigationTreeById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useNavigationTreeById<DataT = NormalizedRpcResponse<'fetchNavigationTreeById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchNavigationTreeById'>>;
     options: UseRpcOptions<'fetchNavigationTreeById', DataT, PickKeys, DefaultT>;
 }>, key?: string): UseRpcReturn<'fetchNavigationTreeById', DataT, PickKeys, DefaultT>;
+/**
+ * Retrieves data of a single navigation tree using the `fetchNavigationTreeByName` RPC method.
+ *
+ *  This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/navigation/get-a-navigation
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getBrands'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `fetchNavigationTreeByName` RPC call.
+ * @param params.params The parameters for the `fetchNavigationTreeByName` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useNavigationTreeByName<DataT = NormalizedRpcResponse<'fetchNavigationTreeById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchNavigationTreeByName'>>;
     options: UseRpcOptions<'fetchNavigationTreeById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useNavigationTrees.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcReturn, UseRpcOptions, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data of all navigation trees using the `fetchAllNavigationTrees` RPC method.
+ *
+ *  This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/navigation/list-navigations
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getBrands'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `fetchAllNavigationTrees` RPC call.
+ * @param params.params The parameters for the `fetchAllNavigationTrees` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useNavigationTrees<DataT = NormalizedRpcResponse<'fetchAllNavigationTrees'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchAllNavigationTrees'>>;
     options: UseRpcOptions<'fetchAllNavigationTrees', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useOrder.d.ts

@@ -7,6 +7,29 @@ type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {
     product: P;
     variant: V;
 };
+/**
+ * Retrieves order data by ID using the `getOrderById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ * It allows for flexible typing of the `product` and `variant` properties within the order items.
+ *
+ * @see https://scayle.dev/en/api-guides/customer-account-api/resources/order/get-order
+ *
+ * @template P The type of the `product` property within the order items. Defaults to an object with any keys.
+ * @template V The type of the `variant` property within the order items. Defaults to an object with any keys.
+ * @template DataT The type of the transformed data. Defaults to `Order & { items?: NewItemsType<P, V>[] }`.
+ * @template PickKeys  Keys of the `DataT` type that will be present. This defaults to all keys of DataT.
+ * @template DefaultT The default return type. Useful for showing loading skeletons. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getOrderById` RPC call.
+ * @param params.params The parameters for the `getOrderById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns An extended async data object containing the order data.
+ */
 export declare function useOrder<P = {
     [k: string]: unknown;
 }, V = {

package/dist/runtime/composables/storefront/useOrderConfirmation.d.ts

@@ -7,6 +7,27 @@ type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {
     product: P;
     variant: V;
 };
+/**
+ * Retrieves order data by ID using the `getOrderDataByCbd RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ * It allows for flexible typing of the `product` and `variant` properties within the order items.
+ *
+ * @template P The type of the `product` property within the order items. Defaults to an object with any keys.
+ * @template V The type of the `variant` property within the order items. Defaults to an object with any keys.
+ * @template DataT The type of the transformed data. Defaults to `Order & { items?: NewItemsType<P, V>[] }`.
+ * @template PickKeys  Keys of the `DataT` type that will be present. This defaults to all keys of DataT.
+ * @template DefaultT The default return type. Useful for showing loading skeletons. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getOrderDataByCbd RPC call.
+ * @param params.params The parameters for the `getOrderDataByCbd RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns An extended async data object containing the order data.
+ */
 export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, V = {

package/dist/runtime/composables/storefront/useProduct.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data for a single product by its ID using the `getProductById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/products/get-a-product
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getProductById'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getProductById` RPC call.
+ * @param params.params The parameters for the `getProductById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useProduct<DataT = NormalizedRpcResponse<'getProductById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductById'>>;
     options: UseRpcOptions<'getProductById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProducts.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves product data by its category using the `getProductById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/products/list-products
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getProductById'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getProductById` RPC call.
+ * @param params.params The parameters for the `getProductById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useProducts<DataT = NormalizedRpcResponse<'getProductsByCategory'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByCategory'>>;
     options: UseRpcOptions<'getProductsByCategory', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProductsByIds.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data of multiple products by their ID using the `getProductsByIds` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/products/list-products
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getProductsByIds'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getProductsByIds` RPC call.
+ * @param params.params The parameters for the `getProductsByIds` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useProductsByIds<DataT = NormalizedRpcResponse<'getProductsByIds'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByIds'>>;
     options: UseRpcOptions<'getProductsByIds', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProductsByReferenceKeys.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data of multiple products by their reference keys using the `getProductsByReferenceKeys` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/products/list-products
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getProductsByReferenceKeys'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getProductsByReferenceKeys` RPC call.
+ * @param params.params The parameters for the `getProductsByReferenceKeys` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useProductsByReferenceKeys<DataT = NormalizedRpcResponse<'getProductsByReferenceKeys'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByReferenceKeys'>>;
     options: UseRpcOptions<'getProductsByReferenceKeys', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProductsCount.d.ts

@@ -1,6 +1,25 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves product count of a category by its ID using the `getProductsCount` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ * *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getProductsCount'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getProductsCount` RPC call.
+ * @param params.params The parameters for the `getProductsCount` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useProductsCount<DataT = NormalizedRpcResponse<'getProductsCount'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsCount'>>;
     options: UseRpcOptions<'getProductsCount', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/usePromotions.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data for all available promotion using the `getPromotions` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/promotions/list-promotions
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getPromotions'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getPromotions` RPC call.
+ * @param params.params The parameters for the `getPromotions` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function usePromotions<DataT = NormalizedRpcResponse<'getPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getPromotions'>>;
     options: UseRpcOptions<'getPromotions', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/usePromotionsByIds.d.ts

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data for multiple  promotions by their IDs using the `getPromotionsByIds` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/promotions/list-promotions
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getPromotionsByIds'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getPromotionsByIds` RPC call.
+ * @param params.params The parameters for the `getPromotionsByIds` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function usePromotionsByIds<DataT = NormalizedRpcResponse<'getPromotionsByIds'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getPromotionsByIds'>>;
     options: UseRpcOptions<'getPromotionsByIds', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useShopConfiguration.d.ts

@@ -1,4 +1,25 @@
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+/**
+ * Retrieves data about the current shop by its shopID using the `getShopConfiguration` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/shop-configuration/get-a-shop-configuration
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getShopConfiguration'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getShopConfiguration` RPC call.
+ * @param params.params The parameters for the `getShopConfiguration` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useShopConfiguration<DataT = NormalizedRpcResponse<'getShopConfiguration'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, }?: Partial<{
     options: UseRpcOptions<'getShopConfiguration', DataT, PickKeys, DefaultT>;
 }>, key?: string): UseRpcReturn<'getShopConfiguration', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useStorefrontSearch.d.ts

@@ -1,6 +1,9 @@
 import type { SearchV2SuggestionsEndpointResponseData, SearchV2With } from '@scayle/storefront-core';
 import type { Status } from '../core/useRpc.js';
 import type { Ref } from 'vue';
+/**
+ * Representation of options for the search composable.
+ */
 export type SearchOptions = Partial<{
     params: Partial<{
         categoryId: number;
@@ -9,7 +12,14 @@ export type SearchOptions = Partial<{
     key: string;
 }>;
 /**
- *   @deprecated `useStorefrontSearch` is deprecated. Consider using `useSearch` of `@scayle/storefront-search` instead.
+ * A composable that provides a way to fetch and manage search suggestions and results.
+ *
+ * @deprecated `useStorefrontSearch` is deprecated. Consider using `useSearch` of `@scayle/storefront-search` instead.
+ *
+ * @param option - An object containing options for the search request.
+ * @param option.with - An object describing which data the returned suggestions/results should contain.
+ *
+ * @returns An object containing reactive data and computed properties for managing search results and suggestions.
  */
 export declare function useStorefrontSearch(searchQuery: Ref<string>, { params }?: SearchOptions, key?: string): {
     data: Ref<SearchV2SuggestionsEndpointResponseData | undefined, SearchV2SuggestionsEndpointResponseData | undefined>;