@scayle/storefront-nuxt 7.84.3 → 7.84.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @scayle/storefront-nuxt
 
+## 7.84.5
+
+### Patch Changes
+
+- Updated dependencies
+  - @scayle/storefront-core@7.64.1
+
+## 7.84.4
+
+### Patch Changes
+
+- Improve type definitions for exported composables
+
 ## 7.84.3
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.d852fe87.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.mjs';
 export { rpcCall } from './rpc.mjs';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.d852fe87.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.js';
 export { rpcCall } from './rpc.js';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';

package/dist/module.d.mts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.d852fe87.mjs';
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.d852fe87.mjs';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.891170da.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.mjs';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/module.d.ts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.d852fe87.js';
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.d852fe87.js';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.891170da.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.js';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/module.json

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

package/dist/module.mjs

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

package/dist/rpc.d.mts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.d852fe87.mjs';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.891170da.mjs';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';

package/dist/rpc.d.ts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.d852fe87.js';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.891170da.js';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';

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

@@ -1,35 +1,8 @@
 import type { MaybeRefOrGetter } from 'vue';
-import type { RpcMethodParameters } from '@scayle/storefront-core';
-export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): {
-    data: import("vue").Ref<{
-        [k: string]: string;
-    }, {
-        [k: string]: string;
-    }>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    fetching: import("vue").Ref<boolean, boolean>;
-    error: import("vue").Ref<any, any>;
-    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    handleIDPLoginCallback: (params: string | {
-        code: string;
-    }) => Promise<{
-        message: string;
-    }>;
-} & Promise<{
-    data: import("vue").Ref<{
-        [k: string]: string;
-    }, {
-        [k: string]: string;
-    }>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    fetching: import("vue").Ref<boolean, boolean>;
-    error: import("vue").Ref<any, any>;
-    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    handleIDPLoginCallback: (params: string | {
-        code: string;
-    }) => Promise<{
-        message: string;
-    }>;
-}>;
+import type { RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+import { type UseRpcReturn } from '../core/useRpc';
+type UseIDPBaseReturn = Pick<Awaited<UseRpcReturn<'getExternalIdpRedirect'>>, 'data' | 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
+    handleIDPLoginCallback: (params: RpcMethodParameters<'handleIDPLoginCallback'>) => RpcMethodReturnType<'handleIDPLoginCallback'>;
+};
+export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): UseIDPBaseReturn & Promise<UseIDPBaseReturn>;
+export {};

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

@@ -1,4 +1,6 @@
 import type { ShopUser, UpdatePasswordParams } from '@scayle/storefront-core';
+import { type UseRpcReturn } from './useRpc';
+import { type ComputedRef } from '#imports';
 export type ExtendedUseUserParams = {
     key?: string;
     /** @deprecated use immediate instead */
@@ -6,26 +8,13 @@ export type ExtendedUseUserParams = {
     immediate?: boolean;
     lazy?: boolean;
 };
-export declare function useUser(options?: ExtendedUseUserParams): {
-    user: import("vue").ComputedRef<ShopUser | undefined>;
-    isLoggedIn: import("vue").ComputedRef<boolean>;
-    customerType: import("vue").ComputedRef<"guest" | "new" | "existing">;
-    fetching: import("vue").Ref<boolean, boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    forceRefresh: () => Promise<void>;
+type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'status' | 'fetch' | 'fetching'> & {
     updateUser: (payload: Partial<ShopUser>) => Promise<void>;
     updatePassword: (payload: UpdatePasswordParams) => Promise<void>;
-    error: import("vue").Ref<any, any>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-} & Promise<{
-    user: import("vue").ComputedRef<ShopUser | undefined>;
-    isLoggedIn: import("vue").ComputedRef<boolean>;
-    customerType: import("vue").ComputedRef<"guest" | "new" | "existing">;
-    fetching: import("vue").Ref<boolean, boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    user: ComputedRef<ShopUser | undefined>;
+    isLoggedIn: ComputedRef<boolean>;
+    customerType: ComputedRef<'new' | 'guest' | 'existing'>;
     forceRefresh: () => Promise<void>;
-    updateUser: (payload: Partial<ShopUser>) => Promise<void>;
-    updatePassword: (payload: UpdatePasswordParams) => Promise<void>;
-    error: import("vue").Ref<any, any>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-}>;
+};
+export declare function useUser(options?: ExtendedUseUserParams): UseUserBaseReturn & Promise<UseUserBaseReturn>;
+export {};

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

@@ -1,125 +1,45 @@
-import type { AddOrUpdateItemType, RpcMethodParameters, BasketResponseData } from '@scayle/storefront-core';
+import type { AddOrUpdateItemType, RpcMethodParameters, RpcMethodReturnType, BasketItem, Product, BasketTotalPrice } from '@scayle/storefront-core';
 import { ExistingItemHandling } from '@scayle/storefront-core';
-import { type MaybeRefOrGetter } from '#imports';
+import { type UseRpcReturn } from '../core/useRpc';
+import { type MaybeRefOrGetter, type ComputedRef } from '#imports';
+import type { BasketKey, BasketPackageInformation } from '@scayle/storefront-api';
 type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBasket'>>;
     key: string;
 }>;
-export declare function useBasket({ params, key, }?: UseBasketOptions): {
-    data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>, BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>>;
-    items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[]>;
-    cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice>;
-    key: import("vue").ComputedRef<import("@scayle/storefront-api").BasketKey>;
-    packages: import("vue").ComputedRef<import("@scayle/storefront-api").BasketPackageInformation[]>;
-    shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
-    isEmpty: import("vue").ComputedRef<boolean>;
-    fetching: import("vue").Ref<boolean, boolean>;
-    pending: import("vue").Ref<boolean, boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    count: import("vue").ComputedRef<number>;
-    countWithoutSoldOutItems: import("vue").ComputedRef<number>;
-    addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {
+type UseBasketBaseReturn = Awaited<UseRpcReturn<'getBasket'>> & {
+    addItem: (item: AddOrUpdateItemType & {
         existingItemHandling?: ExistingItemHandling;
     }) => Promise<void>;
-    addItems: (items: AddOrUpdateItemType[], existingItemHandling?: 1) => Promise<void>;
-    removeItem: (item: {
-        variantId: number;
-    }) => Promise<void>;
-    removeItemByKey: (itemKey: string) => Promise<void>;
-    clear: () => Promise<void>;
-    contains: (item: {
+    addItems: (items: AddOrUpdateItemType[], existingItemHandling?: typeof ExistingItemHandling.AddQuantityToExisting) => Promise<void>;
+    mergeBaskets: (args: {
+        fromBasketKey: string;
+        toBasketKey: string;
+    }) => RpcMethodReturnType<'mergeBaskets'>;
+    findItem: (item: {
         variantId: number;
     } | {
         productId: number;
-    }) => boolean;
-    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
-    findItem: (item: {
+    }) => BasketItem | undefined;
+    contains: (item: {
         variantId: number;
     } | {
         productId: number;
-    }) => import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant> | undefined;
-    generateBasketKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
-        keyTemplate: string;
-        hashAlgorithm: import("@scayle/storefront-core").HashAlgorithm;
-        shopId: string;
-        userId: string;
-        log?: import("@scayle/storefront-core").Log;
-    }) => Promise<string>;
-    mergeBaskets: (args: {
-        fromBasketKey: string;
-        toBasketKey: string;
-    }) => Promise<{
-        type: "failure";
-        statusCode: number;
-        basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
-    } | {
-        readonly type: "success";
-        readonly basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
-    } | {
-        readonly type: "failure";
-        readonly basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
-        readonly errors: import("@scayle/storefront-api").AddOrUpdateItemError[];
-    } | undefined>;
-    error: import("vue").Ref<any, any>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-} & Promise<{
-    data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>, BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>>;
-    items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[]>;
-    cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice>;
-    key: import("vue").ComputedRef<import("@scayle/storefront-api").BasketKey>;
-    packages: import("vue").ComputedRef<import("@scayle/storefront-api").BasketPackageInformation[]>;
-    shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
-    isEmpty: import("vue").ComputedRef<boolean>;
-    fetching: import("vue").Ref<boolean, boolean>;
-    pending: import("vue").Ref<boolean, boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    count: import("vue").ComputedRef<number>;
-    countWithoutSoldOutItems: import("vue").ComputedRef<number>;
-    addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {
-        existingItemHandling?: ExistingItemHandling;
-    }) => Promise<void>;
-    addItems: (items: AddOrUpdateItemType[], existingItemHandling?: 1) => Promise<void>;
+    }) => boolean;
     removeItem: (item: {
         variantId: number;
     }) => Promise<void>;
     removeItemByKey: (itemKey: string) => Promise<void>;
     clear: () => Promise<void>;
-    contains: (item: {
-        variantId: number;
-    } | {
-        productId: number;
-    }) => boolean;
-    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
-    findItem: (item: {
-        variantId: number;
-    } | {
-        productId: number;
-    }) => import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant> | undefined;
-    generateBasketKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
-        keyTemplate: string;
-        hashAlgorithm: import("@scayle/storefront-core").HashAlgorithm;
-        shopId: string;
-        userId: string;
-        log?: import("@scayle/storefront-core").Log;
-    }) => Promise<string>;
-    mergeBaskets: (args: {
-        fromBasketKey: string;
-        toBasketKey: string;
-    }) => Promise<{
-        type: "failure";
-        statusCode: number;
-        basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
-    } | {
-        readonly type: "success";
-        readonly basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
-    } | {
-        readonly type: "failure";
-        readonly basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
-        readonly errors: import("@scayle/storefront-api").AddOrUpdateItemError[];
-    } | undefined>;
-    error: import("vue").Ref<any, any>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-}>;
+    products: ComputedRef<Product[]>;
+    count: ComputedRef<number>;
+    countWithoutSoldOutItems: ComputedRef<number>;
+    items: ComputedRef<BasketItem[]>;
+    cost: ComputedRef<BasketTotalPrice>;
+    key: ComputedRef<BasketKey>;
+    isEmpty: ComputedRef<boolean>;
+    packages: ComputedRef<BasketPackageInformation[]>;
+    shippingDates: ComputedRef<(string | null)[] | undefined>;
+};
+export declare function useBasket({ params, key, }?: UseBasketOptions): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
 export {};

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

@@ -11,7 +11,10 @@ import { computed } from "vue";
 import { extendPromise } from "../../utils/promise.mjs";
 import { useRpc } from "../core/useRpc.mjs";
 import { useRpcCall } from "../core/useRpcCall.mjs";
-import { toValue, toRef } from "#imports";
+import {
+  toValue,
+  toRef
+} from "#imports";
 export function useBasket({
   params,
   key = "useBasket"
@@ -152,7 +155,7 @@ export function useBasket({
   const shippingDates = computed(
     () => packages.value ? getShippingDates(packages.value) : void 0
   );
-  return extendPromise(asyncData.then(() => ({})), {
+  return extendPromise(asyncData, {
     data,
     items,
     cost,

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

@@ -1,5 +1,5 @@
-import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions } from '../core/useRpc';
+import type { RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoriesByPath'>>;
@@ -7,45 +7,8 @@ type Options = Partial<{
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): {
-    data: import("vue").Ref<{
-        categories: import("@scayle/storefront-api").Category[];
-        activeNode: undefined;
-    } | {
-        categories: import("@scayle/storefront-api").Category;
-        activeNode: import("@scayle/storefront-api").Category;
-    }, {
-        categories: import("@scayle/storefront-api").Category[];
-        activeNode: undefined;
-    } | {
-        categories: import("@scayle/storefront-api").Category;
-        activeNode: import("@scayle/storefront-api").Category;
-    }>;
-    error: import("vue").Ref<any, any>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    fetching: import("vue").Ref<boolean, boolean>;
-    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
-} & Promise<{
-    data: import("vue").Ref<{
-        categories: import("@scayle/storefront-api").Category[];
-        activeNode: undefined;
-    } | {
-        categories: import("@scayle/storefront-api").Category;
-        activeNode: import("@scayle/storefront-api").Category;
-    }, {
-        categories: import("@scayle/storefront-api").Category[];
-        activeNode: undefined;
-    } | {
-        categories: import("@scayle/storefront-api").Category;
-        activeNode: import("@scayle/storefront-api").Category;
-    }>;
-    error: import("vue").Ref<any, any>;
-    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    fetching: import("vue").Ref<boolean, boolean>;
-    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
-}>;
+type UseCategoriesBaseReturn = Pick<Awaited<UseRpcReturn<'getCategoriesByPath'>>, 'data' | 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
+    getCategoryById: (id: number, includeHidden?: true) => RpcMethodReturnType<'getCategoryById'>;
+};
+export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): UseCategoriesBaseReturn & Promise<UseCategoriesBaseReturn>;
 export {};