@scayle/storefront-nuxt 7.36.3

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

@@ -0,0 +1,54 @@
+import { AddOrUpdateItemType, ExistingItemHandling, RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type UseBasketOptions = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getBasket'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useBasket({ params, options, key, }?: UseBasketOptions): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").BasketResponseData<import("@scayle/storefront-core").Product, import("@scayle/storefront-core").Variant>>;
+    items: import("vue").ComputedRef<import("@scayle/storefront-core").BasketItem<import("@scayle/storefront-core").Product, import("@scayle/storefront-core").Variant>[]>;
+    cost: import("vue").ComputedRef<import("@scayle/storefront-core").BasketTotalPrice>;
+    key: import("vue").ComputedRef<import("@aboutyou/backbone").BasketKey>;
+    packages: import("vue").ComputedRef<import("@aboutyou/backbone").BasketPackageInformation[]>;
+    shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
+    isEmpty: import("vue").ComputedRef<boolean>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    count: import("vue").ComputedRef<number>;
+    countWithoutSoldOutItems: import("vue").ComputedRef<number>;
+    addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {
+        existingItemHandling?: 0 | 1 | 2 | 3 | undefined;
+    }) => Promise<void>;
+    addItems: (items: AddOrUpdateItemType[], existingItemHandling?: 1) => Promise<void>;
+    removeItem: (item: {
+        variantId: number;
+    }) => Promise<void>;
+    clear: () => Promise<void>;
+    contains: (item: {
+        variantId: number;
+    } | {
+        productId: number;
+    }) => boolean;
+    products: import("vue").ComputedRef<import("@scayle/storefront-core").Product[]>;
+    findItem: (item: {
+        variantId: number;
+    } | {
+        productId: number;
+    }) => import("@scayle/storefront-core").BasketItem<import("@scayle/storefront-core").Product, import("@scayle/storefront-core").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 | undefined;
+    }) => Promise<any>;
+    mergeBaskets: (args: {
+        fromBasketKey: string;
+        toBasketKey: string;
+    }) => Promise<any>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,165 @@
+import { generateBasketKey } from "@scayle/storefront-core/dist/utils/keys";
+import {
+  BaseError,
+  ExistingItemHandling,
+  getShippingDates,
+  HttpStatusCode,
+  HttpStatusMessage
+} from "@scayle/storefront-core";
+import { useNuxtApp } from "nuxt/app";
+import { computed } from "vue";
+import { rpcCall } from "../../rpc/rpcCall.mjs";
+import useEventListener from "../core/useEventListener.mjs";
+import { useRpc } from "../core/useRpc.mjs";
+import { useCurrentShop } from "../core/useCurrentShop.mjs";
+import { toValue } from "#imports";
+const onCheckoutUpdate = async (event, fetching, fetchCallback) => {
+  if (fetching) {
+    return;
+  }
+  if (event?.data?.type === "tracking") {
+    const actionType = event.data.event?.event;
+    if (actionType === "add_to_cart" || actionType === "remove_from_cart") {
+      await fetchCallback();
+    }
+  }
+};
+export async function useBasket({
+  params,
+  options,
+  key = "useBasket"
+} = {}) {
+  const nuxtApp = useNuxtApp();
+  const shop = useCurrentShop();
+  const { data, fetch, fetching, error, status } = await useRpc(
+    "getBasket",
+    key,
+    params,
+    options
+  );
+  useEventListener(
+    "message",
+    (event) => onCheckoutUpdate(event, fetching.value, fetch)
+  );
+  const addItem = async ({
+    variantId,
+    promotionId,
+    quantity,
+    existingItemHandling,
+    displayData,
+    customData,
+    itemGroup
+  }) => {
+    data.value = await rpcCall(
+      nuxtApp,
+      "addItemToBasket",
+      toValue(shop)
+    )({
+      promotionId,
+      variantId,
+      quantity,
+      existingItemHandling,
+      displayData,
+      customData,
+      itemGroup,
+      with: toValue(params)
+    });
+  };
+  const addItems = async (items2, existingItemHandling = ExistingItemHandling.AddQuantityToExisting) => {
+    data.value = await rpcCall(
+      nuxtApp,
+      "addItemsToBasket",
+      toValue(shop)
+    )({
+      items: items2,
+      existingItemHandling,
+      with: toValue(params)
+    });
+  };
+  const mergeBaskets = async (args) => {
+    return await rpcCall(
+      nuxtApp,
+      "mergeBaskets",
+      toValue(shop)
+    )({
+      ...args,
+      with: toValue(params)
+    });
+  };
+  const findItem = (item) => {
+    return data.value?.items?.find((entry) => {
+      if ("variantId" in item) {
+        return entry.variant.id === item.variantId;
+      }
+      return entry.product.id === item.productId;
+    });
+  };
+  const contains = (item) => {
+    return findItem(item) !== void 0;
+  };
+  const removeItem = async (item) => {
+    const element = findItem(item);
+    if (!element) {
+      throw new BaseError(
+        HttpStatusMessage.NOT_FOUND,
+        HttpStatusCode.NOT_FOUND,
+        `Could not find basket item by variant-id: ${item.variantId}`
+      );
+    }
+    data.value = await rpcCall(
+      nuxtApp,
+      "removeItemFromBasket",
+      toValue(shop)
+    )({
+      itemKey: element.key,
+      with: toValue(params)
+    });
+  };
+  const clear = async () => {
+    await rpcCall(nuxtApp, "clearBasket", toValue(shop))();
+  };
+  const products = computed(
+    () => data.value?.items.map((item) => item.product) || []
+  );
+  const count = computed(
+    () => data.value?.items?.reduce((prev, current) => prev + current.quantity, 0)
+  );
+  const countWithoutSoldOutItems = computed(
+    () => data.value?.items?.reduce(
+      (prev, current) => prev + (current.product.isSoldOut ? 0 : current.quantity),
+      0
+    )
+  );
+  const items = computed(() => data.value?.items);
+  const cost = computed(() => data.value?.cost);
+  const basketKey = computed(() => data.value?.key);
+  const isEmpty = computed(() => count.value === 0);
+  const packages = computed(() => data.value?.packages);
+  const shippingDates = computed(
+    () => packages.value ? getShippingDates(packages.value) : void 0
+  );
+  return {
+    data,
+    items,
+    cost,
+    key: basketKey,
+    packages,
+    shippingDates,
+    isEmpty,
+    fetching,
+    fetch,
+    count,
+    countWithoutSoldOutItems,
+    addItem,
+    addItems,
+    removeItem,
+    clear,
+    contains,
+    products,
+    findItem,
+    generateBasketKey,
+    mergeBaskets,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,16 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getBrandById'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useBrand({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").Brand>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useBrand({
+  params,
+  options,
+  key = "useBrand"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getBrandById",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,16 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getBrands'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useBrands({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").BrandsEndpointResponseData>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useBrands({
+  params,
+  options,
+  key = "useBrands"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getBrands",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,20 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getCategoriesByPath'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useCategories({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<{
+        categories: import("@scayle/storefront-core").Category | import("@scayle/storefront-core").Category[];
+        activeNode: import("@scayle/storefront-core").Category | undefined;
+    }>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-core").Category>;
+}>;
+export {};

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

@@ -0,0 +1,30 @@
+import { useNuxtApp } from "nuxt/app";
+import { useRpc } from "../core/useRpc.mjs";
+import { useCurrentShop } from "../core/useCurrentShop.mjs";
+import { rpcCall } from "../../rpc/rpcCall.mjs";
+export async function useCategories({
+  params,
+  options,
+  key = "useCategories"
+} = {}) {
+  const currentShop = useCurrentShop();
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getCategoriesByPath",
+    key,
+    params,
+    options
+  );
+  const getCategoryById = rpcCall(
+    useNuxtApp(),
+    "getCategoryById",
+    currentShop.value ?? void 0
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status,
+    getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
+  };
+}

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

@@ -0,0 +1,16 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getCurrentPromotions'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useCurrentPromotions({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").PromotionsResponseData>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useCurrentPromotions({
+  params,
+  options,
+  key = "useCurrentPromotions"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getCurrentPromotions",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,48 @@
+import { FilterParams, ProductWith } from '@scayle/storefront-core';
+type FacetParams = Partial<{
+    with: {
+        product?: ProductWith;
+    };
+    includedFilters: string[];
+    includeSoldOut: boolean;
+    includeSellableForFree: boolean;
+}>;
+type Options = Partial<{
+    params: FacetParams;
+    key: string;
+}>;
+export declare function useFacet({ key, params, }?: Options): Promise<{
+    filters: import("vue").ComputedRef<import("@aboutyou/backbone").FiltersEndpointResponseData>;
+    filtersFetching: import("vue").Ref<boolean>;
+    unfilteredCount: import("vue").ComputedRef<number>;
+    filterStatus: import("vue").Ref<import("../core/useRpc").Status>;
+    filterError: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    productCountData: import("vue").Ref<import("@scayle/storefront-core").FetchProductsCountResponse>;
+    refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
+    productCountFetching: import("vue").Ref<boolean>;
+    productCountError: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    productCountStatus: import("vue").Ref<import("../core/useRpc").Status>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-core").Product[]>;
+    pagination: import("vue").ComputedRef<import("@scayle/storefront-core").Pagination>;
+    productsFetching: import("vue").Ref<boolean>;
+    filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
+    productError: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    productStatus: import("vue").Ref<import("../core/useRpc").Status>;
+    categories: import("vue").ComputedRef<import("@scayle/storefront-core").Category | import("@scayle/storefront-core").Category[]>;
+    selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-core").Category | undefined>;
+    categoriesFetching: import("vue").Ref<boolean>;
+    categoriesError: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    categoriesStatus: import("vue").Ref<import("../core/useRpc").Status>;
+    fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
+        path: string;
+        pricePromotionKey?: string | undefined;
+        cache?: Partial<{
+            ttl: number;
+            cacheKey: string;
+            cacheKeyPrefix: string;
+            timeout: number;
+        }> | undefined;
+    }) => Promise<true | undefined>;
+    fetchPage: (pageToFetch: number) => Promise<void>;
+}>;
+export {};

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

@@ -0,0 +1,193 @@
+import { useState } from "nuxt/app";
+import { computed } from "vue";
+import { useCategories } from "../storefront/useCategories.mjs";
+import { useFilters } from "../storefront/useFilters.mjs";
+import { useProducts } from "../storefront/useProducts.mjs";
+import { useProductsCount } from "../storefront/useProductsCount.mjs";
+export async function useFacet({
+  key = "useFacet",
+  params = {}
+} = {}) {
+  const currentPath = useState(`${key}-path`, () => "");
+  const currentPage = useState(
+    `${key}-currentPage`,
+    () => 1
+  );
+  const currentPerPage = useState(`${key}-itemsPerPAge`, () => 20);
+  const currentWhereCondition = useState(
+    `${key}-whereCondition`
+  );
+  const currentSorting = useState(`${key}-sorting`);
+  const currentPricePromotionKey = useState(`${key}-pricePromotionKey`);
+  const currentCacheParams = useState(
+    `${key}-currentCacheParams`
+  );
+  const currentOrFiltersOperator = useState(
+    `${key}-orFilterOperator`
+  );
+  const productCountWhere = useState(
+    `${key}-productCountWhereCondition`
+  );
+  const {
+    data: categoryData,
+    fetch: refreshCategories,
+    fetching: categoriesFetching,
+    error: categoriesError,
+    status: categoriesStatus
+  } = await useCategories({
+    params: () => ({
+      path: currentPath.value,
+      includeHidden: params.with?.product?.categories?.includeHidden || void 0
+    }),
+    options: { autoFetch: false },
+    key: `${key}-categories`
+  });
+  const categories = computed(() => categoryData.value?.categories);
+  const selectedCategory = computed(() => categoryData.value?.activeNode);
+  const {
+    data: productData,
+    fetch: _refreshProducts,
+    fetching: productsFetching,
+    error: productError,
+    status: productStatus
+  } = await useProducts({
+    params: () => ({
+      page: currentPage.value,
+      perPage: currentPerPage.value,
+      with: params.with?.product,
+      category: currentPath.value,
+      includeSoldOut: params.includeSoldOut,
+      includeSellableForFree: params.includeSellableForFree,
+      where: currentWhereCondition.value,
+      sort: currentSorting.value,
+      pricePromotionKey: currentPricePromotionKey.value,
+      cache: currentCacheParams.value,
+      orFiltersOperator: currentOrFiltersOperator.value
+    }),
+    options: { autoFetch: false },
+    key: `${key}-products`
+  });
+  const {
+    data: productCountData,
+    fetch: _refreshProductCount,
+    fetching: productCountFetching,
+    error: productCountError,
+    status: productCountStatus
+  } = await useProductsCount({
+    params: () => ({
+      category: currentPath.value,
+      includedFilters: params.includedFilters,
+      includeSoldOut: params.includeSoldOut,
+      includeSellableForFree: params.includeSellableForFree,
+      where: productCountWhere.value,
+      orFiltersOperator: currentOrFiltersOperator.value
+    }),
+    options: { autoFetch: false },
+    key: `${key}-productCount`
+  });
+  const {
+    data: filterData,
+    fetch: refreshFilters,
+    fetching: filtersFetching,
+    error: filterError,
+    status: filterStatus
+  } = await useFilters({
+    params: () => ({
+      category: currentPath.value,
+      includedFilters: params.includedFilters,
+      includeSoldOut: params.includeSoldOut,
+      includeSellableForFree: params.includeSellableForFree,
+      where: currentWhereCondition.value,
+      orFiltersOperator: currentOrFiltersOperator.value
+    }),
+    options: { autoFetch: false },
+    key: `${key}-filters`
+  });
+  const pagination = computed(() => productData.value?.pagination);
+  const products = computed(() => productData.value?.products);
+  const filters = computed(() => filterData.value?.filters);
+  const unfilteredCount = computed(() => filterData.value?.unfilteredCount);
+  const refreshProductCount = async ({
+    where = void 0
+  } = {}) => {
+    productCountWhere.value = where;
+    if (productCountFetching.value) {
+      return;
+    }
+    await _refreshProductCount();
+  };
+  const fetchProducts = async ({
+    path,
+    page = 1,
+    perPage = 20,
+    where = void 0,
+    sort = void 0,
+    pricePromotionKey = "",
+    cache,
+    orFiltersOperator = void 0
+  }) => {
+    currentPath.value = path;
+    currentPage.value = page;
+    currentPerPage.value = perPage;
+    currentWhereCondition.value = where;
+    currentSorting.value = sort;
+    currentPricePromotionKey.value = pricePromotionKey;
+    currentCacheParams.value = cache;
+    currentOrFiltersOperator.value = orFiltersOperator;
+    if (categoriesFetching.value || productsFetching.value || filtersFetching.value) {
+      return;
+    }
+    await Promise.all([
+      refreshCategories(),
+      _refreshProducts(),
+      refreshFilters()
+    ]);
+    return true;
+  };
+  const filterProducts = async ({
+    where = void 0,
+    page,
+    sort = void 0,
+    orFiltersOperator = void 0
+  }) => {
+    currentWhereCondition.value = where;
+    currentPage.value = page;
+    currentSorting.value = sort;
+    currentOrFiltersOperator.value = orFiltersOperator;
+    await _refreshProducts();
+  };
+  const fetchPage = async (pageToFetch) => {
+    currentPage.value = pageToFetch;
+    await _refreshProducts();
+  };
+  return {
+    // filter data
+    filters,
+    filtersFetching,
+    unfilteredCount,
+    filterStatus,
+    filterError,
+    // filter preview
+    productCountData,
+    refreshProductCount,
+    productCountFetching,
+    productCountError,
+    productCountStatus,
+    // product data
+    products,
+    pagination,
+    productsFetching,
+    filterProducts,
+    productError,
+    productStatus,
+    // category data
+    categories,
+    selectedCategory,
+    categoriesFetching,
+    categoriesError,
+    categoriesStatus,
+    // other
+    fetchProducts,
+    fetchPage
+  };
+}

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

@@ -0,0 +1,16 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getFilters'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useFilters({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").FetchFiltersResponse>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useFilters({
+  params,
+  options,
+  key = "useFilters"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getFilters",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,16 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'fetchNavigationTreeById'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useNavigationTree({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").NavigationTree>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};