@scayle/storefront-nuxt 8.53.2 → 8.53.3

package/CHANGELOG.md

@@ -1,5 +1,95 @@
 # @scayle/storefront-nuxt
 
+## 8.53.3
+
+### Patch Changes
+
+- Enhanced data fetching composables to support reactive keys, aligning with [Nuxt 3.17 data fetching improvements](https://nuxt.com/blog/v3-17#data-fetching-improvements).
+
+  You can now pass a `ref`, `computed`, or getter function as the `key` parameter to `useRpc` and derived composables (like `useProducts`, `useBrand` etc.). When the reactive key changes, the data will automatically re-fetch.
+
+  - **Before:** Keys were static strings.
+  - **After:** Keys can be reactive, enabling dynamic caching and automatic updates.
+
+  ```ts
+  // Before
+  const { data } = await useRpc('getProduct', 'my-static-product-key', {
+    productId: 123,
+  })
+
+  // After
+  const productId = ref(123)
+
+  // The key is now reactive. If `productId` changes, the key updates
+  // to 'product-456' (for example) and triggers a new fetch.
+  const { data } = await useRpc(
+    'getProduct',
+    () => `product-${productId.value}`,
+    { productId },
+  )
+  ```
+
+- Deprecated the `CheckoutEvent` type, which will be removed in the next major version.
+
+  This type has been moved to the Storefront Application to better align with application-specific tracking requirements.
+
+  If you are currently importing `CheckoutEvent` from `@scayle/storefront-nuxt`, you should migrate to using the type definition from the Storefront Application or define it locally in your codebase.
+
+  The type definition remains unchanged, so you can copy it directly:
+
+  ```ts
+  import type { ShopUser } from '@scayle/storefront-nuxt'
+
+  export interface CheckoutEvent {
+    /** Action. */
+    action?: 'authenticated'
+    /** Type. */
+    type?: 'tracking'
+    /** User. */
+    user: ShopUser
+    /**
+     * The OAuth 2.0 access token for the authenticated user.
+     * This token can be used to access protected resources on behalf of the user.
+     *
+     * @see https://www.rfc-editor.org/rfc/rfc6749
+     */
+    accessToken: string
+    /**
+     * Details about a specific event within the checkout process.
+     * This field is optional and is only used when tracking specific actions
+     * like `add_to_cart` or `remove_from_cart`.
+     *
+     * @see https://scayle.dev/en/core-documentation/storefront/checkout-guide/tracking
+     */
+    event?: {
+      /** Event name. */
+      event: 'login' | 'add_to_cart' | 'remove_from_cart'
+      /** Event status. */
+      status: 'successful' | 'error'
+    }
+  }
+  ```
+
+- Updated the `StorefrontRuntimeConfig` type to ensure configured `shops` correctly incorporates all extended properties from `AdditionalShopConfig`.
+
+  ```ts
+  declare module '@scayle/storefront-nuxt' {
+    // Extend the shop config
+    export interface AdditionalShopConfig {
+      extendedProp: string
+    }
+  }
+
+  // `extendedProp` is now properly typed
+  useRuntimeConfig().storefront.shops?.[shopId]?.extendedProp
+  ```
+
+**Dependencies**
+
+**@scayle/storefront-core v8.53.3**
+
+- No changes in this release.
+
 ## 8.53.2
 
 ### Patch Changes

package/dist/module.json

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

package/dist/module.mjs

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

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

@@ -1,6 +1,6 @@
 import type { MaybeRefOrGetter } from 'vue';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcReturn } from '../core/useRpc.js';
+import { type UseRpcReturn, type UseRpcCacheKey } from '../core/useRpc.js';
 /**
  * The shape of the data returned by the `getExternalIdpRedirect` RPC call.
  */
@@ -19,5 +19,5 @@ type UseIDPBaseReturn = Pick<Awaited<UseRpcReturn<'getExternalIdpRedirect'>>, 'd
             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 declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: UseRpcCacheKey): UseIDPBaseReturn & Promise<UseIDPBaseReturn>;
 export {};

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

@@ -24,6 +24,10 @@ export type NormalizedRpcResponse<N extends RpcMethodName> = Exclude<Awaited<Rpc
  * @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>;
+/**
+ * Type of the key parameter for the `useRpc` composable.
+ */
+export type UseRpcCacheKey = Parameters<typeof useAsyncData>[0];
 /**
  * Return type of the `useRpc` composable, extending `ExtendedAsyncData`.
  *
@@ -91,5 +95,5 @@ export declare const defaultCachedData: <ResponseT>(key: string, nuxtApp: NuxtAp
  *    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 declare function useRpc<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>>(method: N, key: UseRpcCacheKey, 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/useRpc.js

@@ -43,6 +43,7 @@ export function useRpc(method, key, params, options) {
       );
     },
     {
+      // TODO v9: Remove automatically watching params with next major and solely rely on passed watch options and reactive keys
       // Both refs and getter functions are valid watch sources
       ...isRef(params) || typeof params === "function" ? { watch: [params] } : {},
       getCachedData: storefront.legacy?.enableDefaultGetCachedDataOverride ? defaultCachedData : void 0,

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

@@ -1,12 +1,12 @@
 import type { ShopUser, UpdatePasswordParams } from '@scayle/storefront-core';
-import type { UseRpcReturn } from './useRpc.js';
+import { type UseRpcReturn, type UseRpcCacheKey } 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;
+    key?: UseRpcCacheKey;
     /** Whether to fetch the user data immediately. Defaults to `true`. */
     immediate?: boolean;
     /** Whether to enable lazy loading of user data. Defaults to `false`. */

package/dist/runtime/composables/core/useUser.js

@@ -24,8 +24,8 @@ export function useUser(options = {}) {
       lazy,
       server: false,
       dedupe: "defer",
-      getCachedData: (key2) => {
-        return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
+      getCachedData: (cacheKey) => {
+        return toValue(nuxtApp._asyncData[cacheKey]?.data) ?? void 0;
       }
     }
   );

package/dist/runtime/composables/index.d.ts

@@ -3,7 +3,7 @@ export * from './core/useCurrentShop.js';
 export * from './core/useFormatHelpers.js';
 export * from './core/useIDP.js';
 export * from './core/useLog.js';
-export { useRpc, type KeysOf, type NormalizedRpcResponse, type UseRpcOptions, type UseRpcReturn, type Status, type ExtendedAsyncData, } from './core/useRpc.js';
+export { useRpc, type KeysOf, type NormalizedRpcResponse, type UseRpcOptions, type UseRpcReturn, type UseRpcCacheKey, type Status, type ExtendedAsyncData, } from './core/useRpc.js';
 export * from './core/useRpcCall.js';
 export * from './core/useSession.js';
 export * from './core/useUser.js';

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

@@ -1,6 +1,6 @@
 import type { AddOrUpdateItemType, RpcMethodParameters, BasketResponseData, BasketItem, Product, BasketTotalPrice, BasketItemUpdateData } from '@scayle/storefront-core';
 import { ExistingItemHandling, generateBasketKey } from '@scayle/storefront-core';
-import type { NormalizedRpcResponse, UseRpcReturn } from '../core/useRpc.js';
+import { type NormalizedRpcResponse, type UseRpcReturn, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter, ComputedRef, Ref } from 'vue';
 import type { BasketKey, BasketPackageInformation } from '@scayle/storefront-api';
 /**
@@ -8,7 +8,6 @@ import type { BasketKey, BasketPackageInformation } from '@scayle/storefront-api
  */
 type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<Omit<RpcMethodParameters<'getBasket'>, 'orderCustomData'>>;
-    key: string;
 }>;
 type UseBasketBaseReturn = Omit<Awaited<UseRpcReturn<'getBasket'>>, 'data'> & {
     data: Ref<NormalizedRpcResponse<'getBasket'>['basket'] | null>;
@@ -81,5 +80,5 @@ type UseBasketBaseReturn = Omit<Awaited<UseRpcReturn<'getBasket'>>, 'data'> & {
  *
  * @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 declare function useBasket({ params, }?: UseBasketOptions, key?: UseRpcCacheKey): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
 export {};

package/dist/runtime/composables/storefront/useBasket.js

@@ -6,7 +6,9 @@ import {
   wasAddedWithReducedQuantity
 } from "@scayle/storefront-core";
 import { extendPromise } from "../../utils/promise.js";
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 import { useRpcCall } from "../core/useRpcCall.js";
 import { toValue, computed } from "vue";
 import { FetchError } from "ofetch";
@@ -36,8 +38,8 @@ export function useBasket({
     watch: [sanitizedParams],
     dedupe: "defer",
     transform: (basketResponse) => basketResponse.basket,
-    getCachedData: (key2, nuxtApp) => {
-      return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
+    getCachedData: (cacheKey, nuxtApp) => {
+      return toValue(nuxtApp._asyncData[cacheKey]?.data) ?? void 0;
     }
   });
   const {

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves brand data using the `getBrandById` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getBrandById', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getBrandById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useBrand.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useBrand({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves multiple brands data using the 'getBrands' RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getBrands', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getBrands', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useBrands.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useBrands({
   params,
   options

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

@@ -1,4 +1,4 @@
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 /**
  * Retrieves the first active campaign.
  *
@@ -15,4 +15,4 @@ import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from
  */
 export declare function useCampaign<DataT = NormalizedRpcResponse<'getCampaign'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, }?: Partial<{
     options: UseRpcOptions<'getCampaign', DataT, PickKeys, DefaultT>;
-}>, key?: string): UseRpcReturn<'getCampaign', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getCampaign', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCampaign.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useCampaign({
   options
 } = {}, key = "useCampaign") {

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 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'>;
@@ -35,5 +35,5 @@ type UseCategoriesBaseReturn<DataT, PickKeys extends KeysOf<DataT>, DefaultT> =
 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>;
-}>, key?: string): UseCategoriesBaseReturn<DataT, PickKeys, DefaultT> & Promise<UseCategoriesBaseReturn<DataT, PickKeys, DefaultT>>;
+}>, key?: UseRpcCacheKey): UseCategoriesBaseReturn<DataT, PickKeys, DefaultT> & Promise<UseCategoriesBaseReturn<DataT, PickKeys, DefaultT>>;
 export {};

package/dist/runtime/composables/storefront/useCategories.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 import { extendPromise } from "../../utils/promise.js";
 import { useRpcCall } from "../core/useRpcCall.js";
 export function useCategories({

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data for a single category by its ID using the `getCategoryById` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getCategoryById', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getCategoryById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCategoryById.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useCategoryById({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data for a single category by its path using the `getCategoryByPath` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}, key?: string): UseRpcReturn<'getCategoryByPath', DataT, PickKeys, DefaultT>;
+}, key?: UseRpcCacheKey): UseRpcReturn<'getCategoryByPath', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCategoryByPath.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useCategoryByPath({
   params,
   options

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

@@ -1,9 +1,9 @@
 import type { MaybeRefOrGetter } from 'vue';
-import type { KeysOf, NormalizedRpcResponse, UseRpcOptions, UseRpcReturn } from '../core/useRpc.js';
+import { type KeysOf, type NormalizedRpcResponse, type UseRpcOptions, type UseRpcReturn, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 type UseCategoriesBaseReturn<DataT, PickKeys extends KeysOf<DataT>, DefaultT> = Awaited<UseRpcReturn<'getCategoryTree', DataT, PickKeys, DefaultT>> & Promise<Awaited<UseRpcReturn<'getCategoryTree', DataT, PickKeys, DefaultT>>>;
 export declare function useCategoryTree<DataT = NormalizedRpcResponse<'getCategoryTree'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryTree'>>;
     options: UseRpcOptions<'getCategoryTree', DataT, PickKeys, DefaultT>;
-}>, key?: string): UseCategoriesBaseReturn<DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseCategoriesBaseReturn<DataT, PickKeys, DefaultT>;
 export {};

package/dist/runtime/composables/storefront/useCategoryTree.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useCategoryTree({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data of the current active promotion data using the `getCurrentPromotions` RPC method.
@@ -28,4 +28,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getCurrentPromotions', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getCurrentPromotions', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useCurrentPromotions.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useCurrentPromotions({
   params,
   options
@@ -8,9 +10,9 @@ export function useCurrentPromotions({
     key,
     params,
     {
-      getCachedData(key2, nuxtApp) {
-        const hydrationData = nuxtApp.isHydrating ? nuxtApp.payload.data[key2] : nuxtApp.static.data[key2];
-        return hydrationData ?? nuxtApp._asyncData[key2]?.data.value;
+      getCachedData(cacheKey, nuxtApp) {
+        const hydrationData = nuxtApp.isHydrating ? nuxtApp.payload.data[cacheKey] : nuxtApp.static.data[cacheKey];
+        return hydrationData ?? nuxtApp._asyncData[cacheKey]?.data.value;
       },
       ...options
     }

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves filter data using the `getFilters` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getFilters', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getFilters', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useFilters.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useFilters({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data of a single navigation tree using the `fetchNavigationTreeById` RPC method.
@@ -25,7 +25,7 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'fetchNavigationTreeById', DataT, PickKeys, DefaultT>;
 /**
  * Retrieves data of a single navigation tree using the `fetchNavigationTreeByName` RPC method.
  *
@@ -50,4 +50,4 @@ export declare function useNavigationTreeById<DataT = NormalizedRpcResponse<'fet
 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>;
-}>, key?: string): UseRpcReturn<'fetchNavigationTreeByName', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'fetchNavigationTreeByName', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useNavigationTree.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useNavigationTreeById({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcReturn, UseRpcOptions, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcReturn, type UseRpcOptions, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data of all navigation trees using the `fetchAllNavigationTrees` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'fetchAllNavigationTrees', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'fetchAllNavigationTrees', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useNavigationTrees.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useNavigationTrees({
   params = {},
   options

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

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { AsyncDataOptions } from 'nuxt/app';
-import type { KeysOf, ExtendedAsyncData } from '../core/useRpc.js';
+import { type KeysOf, type ExtendedAsyncData, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves order data by ID using the `getOrderById` RPC method.
@@ -28,4 +28,4 @@ import type { MaybeRefOrGetter } from 'vue';
 export declare function useOrder<P = Record<string, unknown>, V = Record<string, unknown>, DataT = Order<P, V>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: {
     params?: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
     options?: AsyncDataOptions<Order<P, V>, DataT, PickKeys, DefaultT>;
-}, key?: string): ExtendedAsyncData<Order<P, V>, unknown, DataT, PickKeys, DefaultT>;
+}, key?: UseRpcCacheKey): ExtendedAsyncData<Order<P, V>, unknown, DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useOrder.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useOrder({
   params,
   options

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

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { AsyncDataOptions } from 'nuxt/app';
-import type { ExtendedAsyncData, KeysOf } from '../core/useRpc.js';
+import { type ExtendedAsyncData, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves order data by ID using the `getOrderDataByCbd RPC method.
@@ -26,4 +26,4 @@ import type { MaybeRefOrGetter } from 'vue';
 export declare function useOrderConfirmation<P = Record<string, unknown>, V = Record<string, unknown>, DataT = Order<P, V>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: {
     params?: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
     options?: AsyncDataOptions<Order<P, V>, DataT, PickKeys, DefaultT>;
-}, key?: string): ExtendedAsyncData<Order<P, V>, unknown, DataT, PickKeys, DefaultT>;
+}, key?: UseRpcCacheKey): ExtendedAsyncData<Order<P, V>, unknown, DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useOrderConfirmation.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useOrderConfirmation({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data for a single product by its ID using the `getProductById` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getProductById', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getProductById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProduct.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useProduct({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves product data by its category using the `getProductById` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getProductsByCategory', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getProductsByCategory', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProducts.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useProducts({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data of multiple products by their ID using the `getProductsByIds` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getProductsByIds', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getProductsByIds', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProductsByIds.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useProductsByIds({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data of multiple products by their reference keys using the `getProductsByReferenceKeys` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getProductsByReferenceKeys', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getProductsByReferenceKeys', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProductsByReferenceKeys.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useProductsByReferenceKeys({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves product count of a category by its ID using the `getProductsCount` RPC method.
@@ -23,4 +23,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getProductsCount', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getProductsCount', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useProductsCount.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useProductsCount({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data for all available promotion using the `getPromotions` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getPromotions', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getPromotions', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/usePromotions.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function usePromotions({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 /**
  * Retrieves data for multiple  promotions by their IDs using the `getPromotionsByIds` RPC method.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getPromotionsByIds', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getPromotionsByIds', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/usePromotionsByIds.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function usePromotionsByIds({
   params,
   options

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

@@ -1,4 +1,4 @@
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 /**
  * Retrieves data about the current shop by its shopID using the `getShopConfiguration` RPC method.
  *
@@ -22,4 +22,4 @@ import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from
  */
 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>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getShopConfiguration', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useShopConfiguration.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useShopConfiguration({
   options
 } = {}, key = "useShopConfiguration") {

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

@@ -1,4 +1,4 @@
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+import { type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type KeysOf, type UseRpcCacheKey } from '../core/useRpc.js';
 /**
  * Retrieves address data for a logged-in user using the `getCategoryById` RPC method.
  *
@@ -22,4 +22,4 @@ import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from
  */
 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>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getShopUserAddresses', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useUserAddresses.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useUserAddresses({
   options
 } = {}, key = "useUserAddresses") {

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
+import { type KeysOf, type UseRpcOptions, type UseRpcReturn, type NormalizedRpcResponse, type UseRpcCacheKey } 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.
@@ -25,4 +25,4 @@ import type { MaybeRefOrGetter } from 'vue';
 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>;
-}>, key?: string): UseRpcReturn<'getVariantById', DataT, PickKeys, DefaultT>;
+}>, key?: UseRpcCacheKey): UseRpcReturn<'getVariantById', DataT, PickKeys, DefaultT>;

package/dist/runtime/composables/storefront/useVariant.js

@@ -1,4 +1,6 @@
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 export function useVariant({
   params,
   options

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

@@ -1,5 +1,5 @@
 import type { Product, WishlistItem, RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcReturn } from '../core/useRpc.js';
+import { type UseRpcReturn, type UseRpcCacheKey } from '../core/useRpc.js';
 import type { MaybeRefOrGetter, ComputedRef } from 'vue';
 /**
  * Representation of options for configuring the `useWishlist` composable.
@@ -68,5 +68,5 @@ type UseWishlistBaseReturn = Awaited<UseRpcReturn<'getWishlist'>> & {
  *
  * @throws {Error} If an item cannot be found during removal or replacement.
  */
-export declare function useWishlist({ params, }?: Options, key?: string): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;
+export declare function useWishlist({ params, }?: Options, key?: UseRpcCacheKey): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;
 export {};

package/dist/runtime/types/module.d.ts

@@ -117,12 +117,16 @@ export interface PublicShopConfig extends Pick<ShopConfig, 'shopId' | 'domain' |
 /**
  * Storefront configuration.
  */
+export interface StorefrontRuntimeConfig extends Omit<StorefrontRuntimeConfigType, 'shops'> {
+    shops: ShopConfigIndexed;
+}
 export type SupportedDriverName = BuiltinDriverName | 'scayleKv';
 /**
  * Module base options. Extends `StorefrontConfig` and `ModuleOption`.
  */
 export type ModuleOptions = ModuleOptionType;
 /**
+ * @deprecated - will be removed in the next major version. Please switch to `CheckoutEvent` in the Storefront Application (v1.15.0).
  * Checkout event used for tracking with Google Tag Manager.
  *
  * @see https://scayle.dev/en/core-documentation/storefront/checkout-guide/implementation/webcomponent#tracking
@@ -159,7 +163,7 @@ export interface ModulePublicRuntimeConfig extends StorefrontPublicRuntimeConfig
 }
 declare module '@nuxt/schema' {
     interface RuntimeConfig {
-        storefront: StorefrontRuntimeConfigType;
+        storefront: StorefrontRuntimeConfig;
     }
     interface PublicRuntimeConfig {
         storefront: ModulePublicRuntimeConfig;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.53.2",
+  "version": "8.53.3",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -90,7 +90,7 @@
     "utility-types": "^3.11.0",
     "vue-router": "^4.4.0",
     "zod": "^4.0.0",
-    "@scayle/storefront-core": "8.53.2",
+    "@scayle/storefront-core": "8.53.3",
     "@scayle/unstorage-compression-driver": "1.2.4"
   },
   "devDependencies": {
@@ -103,7 +103,7 @@
     "@nuxt/schema": "3.20.0",
     "@nuxt/test-utils": "3.20.1",
     "@types/node": "22.19.1",
-    "@vitest/coverage-v8": "4.0.13",
+    "@vitest/coverage-v8": "4.0.14",
     "dprint": "0.50.2",
     "eslint-formatter-gitlab": "6.0.1",
     "eslint": "9.39.1",
@@ -116,7 +116,7 @@
     "publint": "0.3.15",
     "typescript": "5.9.3",
     "unbuild": "3.6.1",
-    "vitest": "4.0.13",
+    "vitest": "4.0.14",
     "vue-tsc": "3.1.5",
     "happy-dom": "20.0.10",
     "@scayle/eslint-config-storefront": "4.7.14",