@scayle/storefront-nuxt 8.11.0 → 8.11.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @scayle/storefront-nuxt
 
+## 8.11.1
+
+### Patch Changes
+
+**Dependencies**
+
+- Updated dependency to @scayle/storefront-core@8.10.0
+
 ## 8.11.0
 
 ### Minor Changes

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "8.11.0",
+  "version": "8.11.1",
   "configKey": "storefront",
   "compatibility": {
     "nuxt": "^3.9.0"

package/dist/module.mjs

@@ -46,7 +46,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "8.11.0";
+const PACKAGE_VERSION = "8.11.1";
 const logger = createConsola({
   fancy: true,
   formatOptions: {

package/dist/runtime/composables/core/useAvailableShops.d.ts

@@ -1,2 +1,12 @@
 import type { PublicShopConfig } from '../../../module.js';
+/**
+ * Provides a reactive list of available shops.
+ *
+ * This composable uses [`useState`](https://nuxt.com/docs/api/composables/use-state)
+ * to create a reactive state variable that holds an array of `PublicShopConfig` objects.
+ * The initial value of the state is an empty array. This state can be used to
+ * dynamically display data of the available shops within the application.
+ *
+ * @returns A reactive `ref` containing an array of available shop configurations.
+ */
 export declare function useAvailableShops(): import("vue").Ref<PublicShopConfig[], PublicShopConfig[]>;

package/dist/runtime/composables/core/useCurrentShop.d.ts

@@ -1,3 +1,13 @@
 import type { Ref } from 'vue';
 import type { PublicShopConfig } from '../../../module.js';
+/**
+ * Provides a reactive reference to the current shop configuration.
+ *
+ * This composable retrieves the current shop configuration from the Nuxt app instance.
+ * It then uses [`useState`](https://nuxt.com/docs/api/composables/use-state) to
+ * create a reactive reference to this configuration, allowing components
+ * to reactively update when the current shop changes.
+ *
+ * @returns A reactive `ref` to the current shop's configuration.
+ */
 export declare const useCurrentShop: () => Ref<PublicShopConfig>;

package/dist/runtime/composables/core/useFormatHelpers.d.ts

@@ -1,20 +1,71 @@
+/**
+ * Representation of options for formatting currencies.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+ */
 type FormatCurrencyOptions = {
+    /**
+     * The locale to use for formatting.
+     */
     locale?: string;
+    /**
+     * The number of fraction digits to use for the currency.
+     */
     currencyFractionDigits?: number;
+    /**
+     * The style ('currency' or 'decimal') to use for formatting. Defaults to 'currency'.
+     */
     style?: 'currency';
+    /**
+     * The currency code (e.g., 'EUR', 'USD') to use for formatting.
+     */
     currency: string;
 } | {
+    /**
+     * The locale to use for formatting.
+     */
     locale?: string;
+    /**
+     * The number of fraction digits to use for the currency.
+     */
     currencyFractionDigits?: number;
+    /**
+     * The style to use for formatting.
+     */
     style: 'decimal';
 };
+/**
+ * Representation of options for formatting percentages.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+ */
+type FormatPercentageOptions = {
+    /**
+     * The locale to use for formatting.
+     */
+    locale?: string;
+    /**
+     * The minimum number of fraction digits to use.
+     */
+    minimumFractionDigits?: number;
+    /**
+     * The maximum number of fraction digits to use.
+     */
+    maximumFractionDigits?: number;
+    /**
+     * How to display the sign for the percentage.
+     */
+    signDisplay?: Intl.NumberFormatOptions['signDisplay'];
+};
+/**
+ * Provides currency and percentage formatting helpers.
+ *
+ * It leverages the current shop's locale and currency settings.
+ *
+ * @returns An object containing the formatCurrency and formatPercentage functions.
+ */
 export declare function useFormatHelpers(): {
     formatCurrency: (value: number, options?: FormatCurrencyOptions) => string;
-    formatPercentage: (value: number, options?: {
-        locale?: string;
-        minimumFractionDigits?: number;
-        maximumFractionDigits?: number;
-        signDisplay?: Intl.NumberFormatOptions["signDisplay"];
-    }) => string;
+    formatPercentage: (value: number, options?: FormatPercentageOptions) => string;
 };
 export {};

package/dist/runtime/composables/core/useIDP.d.ts

@@ -1,6 +1,23 @@
 import type { MaybeRefOrGetter } from 'vue';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import { type UseRpcReturn } from '../core/useRpc.js';
+/**
+ * The shape of the data returned by the `getExternalIdpRedirect` RPC call.
+ */
 type UseIDPBaseReturn = Pick<Awaited<UseRpcReturn<'getExternalIdpRedirect'>>, 'data' | 'error' | 'status' | 'refresh'>;
+/**
+ * Retrieves an external IDP redirect URL.
+ *
+ * This composables uses the `useRpc` composable to call the `getExternalIdpRedirect` RPC method.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication#redirect-url
+ *
+ * @param params The parameters for the `getExternalIdpRedirect` RPC call.
+ * @param key A unique key for the RPC call. Used for caching and invalidation. Defaults to 'useIDP'.
+
+ * @returns An object containing the `data` returned from, any `error` encountered within,
+            the current `status` and a function to manually `refresh` the RPC call.
+ *          It also acts as a promise that resolves to the same object.
+ */
 export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): UseIDPBaseReturn & Promise<UseIDPBaseReturn>;
 export {};

package/dist/runtime/composables/core/useLog.d.ts

@@ -1,2 +1,14 @@
 import type { Log } from '@scayle/storefront-core';
+/**
+ * Retrieves a logging instance.
+ *
+ * It allows for creating a namespaced logger using the provided `subSpace` argument.
+ * If a namespace is specified, the function will return a logger scoped to that subspace.
+ * Otherwise, it returns the root logger.
+ *
+ * @param subSpace The namespace to create the logger for.
+ *
+ * @returns The log instance, a namespace is specified, a logger scoped to that subspace.
+ *          Otherwise, it returns the root logger.
+ */
 export declare function useLog(subSpace?: string): Log;

package/dist/runtime/composables/core/useRpc.d.ts

@@ -1,41 +1,93 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
 import { type AsyncDataOptions, useAsyncData } from 'nuxt/app';
 import { type MaybeRefOrGetter } from 'vue';
+/**
+ * Extracts keys from a type `T` as an array of strings.
+ *
+ * @template T The type from which to extract keys.
+ */
 export type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
-/** The normalized return type of an RPC */
+/**
+ * Normalized return type of a RPC method, excluding its `Response` object.
+ *
+ * @template N The RPC Method Name.
+ */
 export type NormalizedRpcResponse<N extends RpcMethodName> = Exclude<Awaited<RpcMethodReturnType<N>>, Response>;
+/**
+ * Representation of options for the `useRpc` composable, extending `AsyncDataOptions`.
+ *
+ * @template N The RPC Method Name.
+ * @template DataT The data type. Defaults to `NormalizedRpcResponse<N>`.
+ * @template PickKeys The keys to pick from `DataT`. Defaults to all keys of `DataT`.
+ * @template DefaultT  The default value type. Defaults to `null`.
+ * @template ResponseT The response type. Defaults to `NormalizedRpcResponse<N>`.
+ */
 export type UseRpcOptions<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>> = AsyncDataOptions<ResponseT, DataT, PickKeys, DefaultT>;
 /**
- * The return type of a composable based on useRpc
+ * Return type of the `useRpc` composable, extending `ExtendedAsyncData`.
+ *
+ * @template N The RPC Method Name.
+ * @template DataT The data type. Defaults to `NormalizedRpcResponse<N>`.
+ * @template PickKeys The keys to pick from `DataT.` Defaults to all keys of `DataT`.
+ * @template DefaultT The default value type. Defaults to `null`.
+ * @template ResponseT The response type. Defaults to `NormalizedRpcResponse<N>`.
  */
 export type UseRpcReturn<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>> = ExtendedAsyncData<ResponseT, unknown, DataT, PickKeys, DefaultT>;
 export type Status = 'idle' | 'pending' | 'success' | 'error';
 type AsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = ReturnType<typeof useAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
 type AwaitedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = Awaited<AsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
+/**
+ * Extended `AsyncData` type, adding a promise to the result.
+ *
+ * @template ResT The response type.
+ * @template ErrorT The error type. Defaults to `unknown`.
+ * @template DataT The data type. Defaults to `ResT`.
+ * @template PickKeys The keys to pick from `DataT`. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value type. Defaults to `null`.
+ */
 export type ExtendedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT> & Promise<AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
 /**
- * `useRpc` is a wrapper around `useAsyncData` for registered RPC methods
- *
- * This is slightly different from the useRpc we have in Nuxt2
- * It is built on top of useAsyncData and matches its API more than the Nuxt2 API
- * Notably, fetch is now refresh. The fetching property remains the same.
- * It also doesn't directly use rpcCall, instead calling $fetch directly
- * The main difference regards how params are passed:
- * In Nuxt2 for an RPC with params, the params are passed when calling `fetch`.
- * In Nuxt3 for an RPC with params, the params are passed to `useRpc`.
- * Additionally, in Nuxt3 the params can be `Params`, `Ref<Params>` or `() => Params`
- *
- * @param method - the RPC method name
- * @param key - a unique key for persisting the data between server and client and de-duplicating requests
- * @param params - parameters to pass to the RPC method.
- * This can be specified in three ways: as a raw value, a `Ref` or a function that returns the params
- * - When passed as a raw value, the parameters are set at the point `useRpc` is called. Subsequent `refresh` calls will use the same params.
- * - When passed as a function, the function will be invoked each time `refresh` is called to get the params.
- * - When passed as a Ref, a watcher wil be added that calls `refresh` each time params change.
- * @param options - Override the options passed to `useAsyncData`.
- * By default, `useRpc` will set `immediate` to `false` and will pass `[params]` to `watch` if `params` is a `Ref`.
- * But anything passed here will take precedence.
- * @see {@link https://nuxt.com/docs/api/composables/use-async-data#params}
+ * `useRpc` is a wrapper around `useAsyncData` for registered RPC methods.
+ *
+ * This composable provides a declarative approach to data fetching by wrapping
+ * `useAsyncData` for registered RPC methods. It handles the fetch state,
+ * automatically executes the RPC method, and returns the result or any errors.
+ * Many Storefront composables utilize `useRpc` as lightweight wrappers around provided RPC methods.
+ *
+ * The parameters for the RPC call can be passed as a raw value, a ref, or a function.  If a reactive ref or function is provided,
+ * `useRpc` will automatically re-fetch the data when the parameters change.
+ *
+ * By default, `useRpc` utilizes a shared cache, so all instances called with the same key will share the same data.  This behavior can be
+ * disabled globally via the `disableDefaultGetCachedDataOverride` option in the public runtime config, or individually per call using the `options` parameter.
+ *
+ * @see https://nuxt.com/docs/api/composables/use-async-data#params
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#userpc
+ *
+ * @param method The name of the RPC method to call (e.g., 'useBrand).
+ * @param key A unique key for caching, persisting the data between server and client,
+ *            and de-duplicating requests (e.g., 'use-brand').
+ * @param params The parameters for the RPC method. Can be a value, a `Ref`,
+ *               or a function. If reactive, changes will trigger a re-fetch.
+ *                - When passed as a raw value, the parameters are set at the point
+ *                 `useRpc` is called. Subsequent `refresh` calls will use the same params.
+ *                - When passed as a function, the function will be invoked each
+ *                  time `refresh` is called to get the params.
+ *                - When passed as a Ref, a watcher wil be added that
+ *                  calls `refresh` each time params change.
+ * @param options Options for `useAsyncData`, including `watch`, `getCachedData`,
+ *                and more. Can be used to control caching behavior. By default,
+ *                `useRpc` will set `immediate` to `false` and will pass `[params]`
+ *                to `watch` if `params` is a `Ref`.
+ *
+ *  @returns An object containing the `data`, `status`, and other properties from
+ *           `useAsyncData`, as well as a promise that resolves to the data.
+ *
+ * @example
+ * ```typescript
+ *   import { useRpc } from '#storefront/composables'
+ *
+ *    const { data: shopId, fetching } = useRpc('getShopId', 'current-shop-id')
+ * ```
  */
 export declare function useRpc<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>>(method: N, key: string, params?: MaybeRefOrGetter<RpcMethodParameters<N> extends RpcContext ? undefined : RpcMethodParameters<N>>, options?: UseRpcOptions<N, DataT, PickKeys, DefaultT, ResponseT>): ExtendedAsyncData<ResponseT, unknown, DataT, PickKeys, DefaultT>;
 export {};

package/dist/runtime/composables/core/useRpcCall.d.ts

@@ -1,2 +1,42 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+/**
+ * Provides a function for calling a specified RPC method.
+ *
+ * This function acts as a factory, returning a function that can be used to
+ * call the given RPC method. It's designed for calling RPCs in response to
+ * events or user interactions, such as clicking a button or submitting a form.
+ * `useRpcCall` accepts the RPC method name and returns a callback function.
+ * When invoked, this callback receives the RPC parameters, makes the request,
+ * and returns a promise that resolves with the RPC's response.
+ *
+ * @template N The RPC Method Name.
+ * @template P The RPC Method Parameters.
+ * @template TResult The result type of the RPC method, excluding its`Response` object.
+ * @template TakesParameters A boolean indicating whether the RPC method takes parameters.
+ *                           It's `undefined` if the parameters extend `RpcContext`.
+ *
+ * @param method The name of the RPC method.
+ *
+ * @returns A function to call the specified RPC method. This returned function
+ *          will accept the RPC method parameters (if any) and return a Promise
+ *          that resolves with the result of the RPC call.
+ *
+ * @example
+ * ```html
+ * <!-- Example of a `subscribeToNewsletter` RPC method, triggered by a form submission -->
+ * <script setup lang="ts">
+ * import { useRpcCall } from '#storefront/composables'
+ * import { ref } from 'vue';
+ *
+ * const subscribeToNewsletter = useRpcCall('subscribeToNewsletter')
+ * const email = ref('hello@scayle.com')
+ *
+ * const onSubmit = async () => {
+ *   const res = await subscribeToNewsletter({ email: email.value })
+ *
+ *   console.log(res)
+ * }
+ * </script>
+ * ```
+ */
 export declare function useRpcCall<N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TakesParameters = P extends RpcContext ? undefined : boolean>(method: N): TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;

package/dist/runtime/composables/core/useSession.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Provides functions for managing user sessions, including login, registration, guest login, token refresh, revocation, password reset, and IDP login.
+ *
+ * This composable leverages `useRpcCall` to interact with corresponding RPC methods.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/sessions
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication
+ *
+ * @returns An object containing functions for various session management operations.
+ */
 export declare function useSession(): {
     login: (params: import("utility-types").Optional<import("@scayle/storefront-core").LoginRequest, "shop_id">) => Promise<never>;
     register: (params: import("utility-types").Optional<import("@scayle/storefront-core").RegisterRequest, "shop_id">) => Promise<never>;

package/dist/runtime/composables/core/useUser.d.ts

@@ -1,9 +1,15 @@
 import type { ShopUser, UpdatePasswordParams } from '@scayle/storefront-core';
 import { type UseRpcReturn } from './useRpc.js';
 import { type ComputedRef } from 'vue';
+/**
+ * Extended parameters for the `useUser` composable.
+ */
 export type ExtendedUseUserParams = {
+    /** The key used for caching the user data. Defaults to 'useUser'. */
     key?: string;
+    /** Whether to fetch the user data immediately. Defaults to `true`. */
     immediate?: boolean;
+    /** Whether to enable lazy loading of user data. Defaults to `false`. */
     lazy?: boolean;
 };
 type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'status' | 'refresh'> & {
@@ -14,5 +20,23 @@ type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'statu
     customerType: ComputedRef<'new' | 'guest' | 'existing'>;
     forceRefresh: () => Promise<void>;
 };
+/**
+ * Provides user information and related actions.
+ *
+ * This composable retrieves user data via the `getUser` RPC method and offers
+ * functionalities to update user details, change passwords, and force-refresh user data.
+ * It uses `useRpc` for data fetching and provides computed properties for user status,
+ * login status, and customer type.
+ *
+ * The composable also handles caching of user data and allows for lazy loading
+ * and immediate fetching based on the provided options.
+ *
+ * @param options Options to customize the behavior of the composable,
+ *                such as caching key, immediate fetching, and lazy loading.
+ *
+ * @returns A promise that resolves to an object containing user information,
+ *          update functions, and status properties. It also includes the resolved
+ *          object directly as properties.
+ */
 export declare function useUser(options?: ExtendedUseUserParams): UseUserBaseReturn & Promise<UseUserBaseReturn>;
 export {};

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

@@ -5,6 +5,9 @@ import { type NormalizedRpcResponse, type UseRpcReturn } from '../core/useRpc.js
 import { type MaybeRefOrGetter, type ComputedRef, type Ref } from 'vue';
 import type { BasketKey, BasketPackageInformation } from '@scayle/storefront-api';
 import type { BasketItemUpdateData } from '@scayle/storefront-core/dist/rpc/methods/index';
+/**
+ * Representation of options for configuring the `useBasket` composable.
+ */
 type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<Omit<RpcMethodParameters<'getBasket'>, 'orderCustomData'>>;
     key: string;
@@ -58,5 +61,26 @@ type UseBasketBaseReturn = Omit<Awaited<UseRpcReturn<'getBasket'>>, 'data'> & {
     /** @deprecated In a future release `shippingDates` will be removed. Consider using {@link getShippingDates} instead. */
     shippingDates: ComputedRef<(string | null)[] | undefined>;
 };
+/**
+ * Manages basket interactions. Provides functionalities for adding, removing, updating, and clearing
+ * basket items, as well as accessing basket information like items, cost, and count.
+ *
+ * This function acts as a wrapper around the `useRpc` composable for basket data,
+ * simplifying the process of fetching brand data. It internally calls `useRpc`
+ * with the provided parameters and options. It utilizes the `getCachedData` option
+ * within `useRpc` to retrieve cached basket data during hydration or from async data otherwise.
+ * This helps avoid unnecessary re-fetches and improves performance. Specifically,
+ * it checks `nuxtApp._asyncData` for existing data associated with the provided key.
+ * This approach addresses a [Nuxt typing issue](https://github.com/nuxt/nuxt/issues/26093)
+ * requiring a type assertion to `WishlistResponseData`.
+ *
+ * @param options An object containing parameters and options for all basket-related RPC calls.
+ * @param options.params Parameters for the 'getBasket' RPC call (excluding `orderCustomData`).
+ * @param key A unique key for identifying the basket instance. Defaults to 'useBasket'.
+ *
+ * @returns A promise resolving to an object with basket data, methods, and reactive properties.
+ *
+ * @throws {Error} If an item cannot be found during removal or if an item is added with a reduced quantity.  Also throws FetchError if RPC calls fail.
+ */
 export declare function useBasket({ params, }?: UseBasketOptions, key?: string): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
 export {};

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>;

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

@@ -1,4 +1,25 @@
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+/**
+ * Retrieves address data for a logged-in user 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/customer-account-api/resources/customer/address/list-addresses
+ *
+ * @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 useUserAddresses<DataT = NormalizedRpcResponse<'getShopUserAddresses'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, }?: Partial<{
     options: UseRpcOptions<'getShopUserAddresses', DataT, PickKeys, DefaultT>;
 }>, key?: string): UseRpcReturn<'getShopUserAddresses', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useVariant.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 or multiple product variant by its ID using the `getVariantById` 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/variants/get-a-variant
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getVariantById'>`.
+ * @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 `getVariantById` RPC call.
+ * @param params.params The parameters for the `getVariantById` 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 useVariant<DataT = NormalizedRpcResponse<'getVariantById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getVariantById'>>;
     options: UseRpcOptions<'getVariantById', DataT, PickKeys, DefaultT>;

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

@@ -1,6 +1,9 @@
 import type { Product, WishlistItem, RpcMethodParameters } from '@scayle/storefront-core';
 import { type UseRpcReturn } from '../core/useRpc.js';
 import { type MaybeRefOrGetter, type ComputedRef } from 'vue';
+/**
+ * Representation of options for configuring the `useWishlist` composable.
+ */
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getWishlist'>>;
 }>;
@@ -39,5 +42,31 @@ type UseWishlistBaseReturn = Awaited<UseRpcReturn<'getWishlist'>> & {
     items: ComputedRef<WishlistItem[] | undefined>;
     products: ComputedRef<Product[]>;
 };
+/**
+ * Manages wishlist interactions. Fetches wishlist data, provides methods for adding, removing,
+ * replacing, clearing, finding, and toggling items. It leverages RPC calls for data manipulation
+ * and provides reactive properties for count, items, and products.
+ *
+ * This function acts as a wrapper around the `useRpc` composable for wishlist data,
+ * simplifying the process of fetching brand data. It internally calls `useRpc`
+ * with the provided parameters and options. It utilizes the `getCachedData` option
+ * within `useRpc` to retrieve cached wishlist data during hydration or from async data otherwise.
+ * This helps avoid unnecessary re-fetches and improves performance. Specifically,
+ * it checks `nuxtApp._asyncData` for existing data associated with the provided key.
+ * This approach addresses a [Nuxt typing issue](https://github.com/nuxt/nuxt/issues/26093)
+ * requiring a type assertion to `WishlistResponseData`.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/wishlists/get-a-wishlist
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#managing-shared-state-with-userpc
+ *
+ * @param params An object containing parameters and options for all wishlist-related RPC calls.
+ * @param params.params The parameters for the `useWishlist` 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 A promise that resolves to an object containing wishlist data, methods, and reactive properties.
+ *
+ * @throws {Error} If an item cannot be found during removal or replacement.
+ */
 export declare function useWishlist({ params, }?: Options, key?: string): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.11.0",
+  "version": "8.11.1",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -72,7 +72,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@scayle/h3-session": "0.6.0",
-    "@scayle/storefront-core": "8.9.0",
+    "@scayle/storefront-core": "8.10.0",
     "@scayle/unstorage-compression-driver": "^0.2.4",
     "@vercel/nft": "0.29.2",
     "@vueuse/core": "12.7.0",