@epcc-sdk/sdks-shopper 0.0.26 → 0.0.27

package/dist/client/@tanstack/react-query.gen.mjs

@@ -0,0 +1,2598 @@
+import { queryOptions } from "@tanstack/react-query";
+import {
+  getByContextRelease,
+  getByContextAllHierarchies,
+  getByContextHierarchy,
+  getByContextHierarchyNodes,
+  getByContextHierarchyChildNodes,
+  getByContextAllNodes,
+  getByContextNode,
+  getByContextChildNodes,
+  getByContextAllProducts,
+  getByContextProduct,
+  getByContextComponentProductIds,
+  getByContextChildProducts,
+  getByContextProductsForHierarchy,
+  getByContextProductsForNode,
+  configureByContextProduct,
+  getCatalogs,
+  createCatalog,
+  deleteCatalogById,
+  getCatalogById,
+  updateCatalog,
+  deleteReleases,
+  getReleases,
+  publishRelease,
+  deleteReleaseById,
+  getReleaseById,
+  getRules,
+  createRule,
+  deleteRuleById,
+  getRuleById,
+  updateRule,
+  getAllHierarchies,
+  getHierarchy,
+  getHierarchyNodes,
+  getHierarchyChildNodes,
+  getAllNodes,
+  getNode,
+  getChildNodes,
+  getAllProducts,
+  getProduct,
+  getComponentProductIds,
+  getChildProducts,
+  getProductsForHierarchy,
+  getProductsForNode,
+  getCarts,
+  createACart,
+  deleteACart,
+  getCart,
+  updateACart,
+  deleteAllCartItems,
+  getCartItems,
+  manageCarts,
+  bulkUpdateItemsInCart,
+  deleteACartItem,
+  updateACartItem,
+  deleteAccountCartAssociation,
+  createAccountCartAssociation,
+  deleteCustomerCartAssociation,
+  createCustomerCartAssociation,
+  deleteAPromotionViaPromotionCode,
+  addTaxItemToCart,
+  bulkDeleteTaxItemsFromCart,
+  bulkAddTaxItemsToCart,
+  deleteATaxItem,
+  updateATaxItem,
+  bulkDeleteCustomDiscountsFromCart,
+  bulkAddCustomDiscountsToCart,
+  deleteCustomDiscountFromCart,
+  updateCustomDiscountForCart,
+  addCustomDiscountToCartItem,
+  deleteCustomDiscountFromCartItem,
+  updateCustomDiscountForCartItem,
+  createCartPaymentIntent,
+  checkoutApi,
+  getCustomerOrders,
+  getAnOrder,
+  updateAnOrder,
+  getOrderItems,
+  anonymizeOrders,
+  paymentSetup,
+  confirmPayment,
+  captureATransaction,
+  refundATransaction,
+  getOrderTransactions,
+  getATransaction,
+  cancelATransaction,
+  getSubscriptionProduct,
+  getPlan,
+  listOfferings,
+  getOffering,
+  listOfferingPlans,
+  listOfferingFeatures,
+  listOfferingProducts,
+  listSubscriptions,
+  getSubscription,
+  listSubscriptionProducts,
+  listSubscriptionPlans,
+  listSubscriptionStates,
+  getSubscriptionState,
+  listSubscriptionInvoices,
+  listSubscriptionInvoicePayments,
+  getSubscriptionInvoicePayment,
+  getSubscriptionInvoice,
+  listInvoices,
+  getInvoice,
+  getFeature,
+  getStock,
+  listLocations,
+  createAnAccessToken,
+  getV2AccountAddresses,
+  postV2AccountAddress,
+  deleteV2AccountAddress,
+  getV2AccountAddress,
+  putV2AccountAddress,
+  getV2Accounts,
+  postV2Accounts,
+  getV2AccountsAccountId,
+  putV2AccountsAccountId,
+  getV2AccountMembers,
+  getV2AccountMembersAccountMemberId,
+  getV2AccountsAccountIdAccountMemberships,
+  postV2AccountMembersTokens,
+  getAllCurrencies,
+  getACurrency,
+  getAllFiles,
+  getAFile,
+  client
+} from "../sdk.gen.mjs";
+const createQueryKey = (id, options, infinite) => {
+  const params = {
+    _id: id,
+    baseUrl: (options?.client ?? client).getConfig().baseUrl
+  };
+  if (infinite) {
+    params._infinite = infinite;
+  }
+  if (options?.body) {
+    params.body = options.body;
+  }
+  if (options?.headers) {
+    params.headers = options.headers;
+  }
+  if (options?.path) {
+    params.path = options.path;
+  }
+  if (options?.query) {
+    params.query = options.query;
+  }
+  return params;
+};
+const getByContextReleaseQueryKey = (options) => [createQueryKey("getByContextRelease", options)];
+const getByContextReleaseOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextRelease({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextReleaseQueryKey(options)
+  });
+};
+const getByContextAllHierarchiesQueryKey = (options) => [createQueryKey("getByContextAllHierarchies", options)];
+const getByContextAllHierarchiesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextAllHierarchies({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextAllHierarchiesQueryKey(options)
+  });
+};
+const getByContextHierarchyQueryKey = (options) => [createQueryKey("getByContextHierarchy", options)];
+const getByContextHierarchyOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextHierarchy({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextHierarchyQueryKey(options)
+  });
+};
+const getByContextHierarchyNodesQueryKey = (options) => [createQueryKey("getByContextHierarchyNodes", options)];
+const getByContextHierarchyNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextHierarchyNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextHierarchyNodesQueryKey(options)
+  });
+};
+const getByContextHierarchyChildNodesQueryKey = (options) => [createQueryKey("getByContextHierarchyChildNodes", options)];
+const getByContextHierarchyChildNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextHierarchyChildNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextHierarchyChildNodesQueryKey(options)
+  });
+};
+const getByContextAllNodesQueryKey = (options) => [createQueryKey("getByContextAllNodes", options)];
+const getByContextAllNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextAllNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextAllNodesQueryKey(options)
+  });
+};
+const getByContextNodeQueryKey = (options) => [createQueryKey("getByContextNode", options)];
+const getByContextNodeOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextNode({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextNodeQueryKey(options)
+  });
+};
+const getByContextChildNodesQueryKey = (options) => [createQueryKey("getByContextChildNodes", options)];
+const getByContextChildNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextChildNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextChildNodesQueryKey(options)
+  });
+};
+const getByContextAllProductsQueryKey = (options) => [createQueryKey("getByContextAllProducts", options)];
+const getByContextAllProductsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextAllProducts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextAllProductsQueryKey(options)
+  });
+};
+const getByContextProductQueryKey = (options) => [createQueryKey("getByContextProduct", options)];
+const getByContextProductOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextProduct({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextProductQueryKey(options)
+  });
+};
+const getByContextComponentProductIdsQueryKey = (options) => [createQueryKey("getByContextComponentProductIds", options)];
+const getByContextComponentProductIdsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextComponentProductIds({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextComponentProductIdsQueryKey(options)
+  });
+};
+const getByContextChildProductsQueryKey = (options) => [createQueryKey("getByContextChildProducts", options)];
+const getByContextChildProductsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextChildProducts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextChildProductsQueryKey(options)
+  });
+};
+const getByContextProductsForHierarchyQueryKey = (options) => [createQueryKey("getByContextProductsForHierarchy", options)];
+const getByContextProductsForHierarchyOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextProductsForHierarchy({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextProductsForHierarchyQueryKey(options)
+  });
+};
+const getByContextProductsForNodeQueryKey = (options) => [createQueryKey("getByContextProductsForNode", options)];
+const getByContextProductsForNodeOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getByContextProductsForNode({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getByContextProductsForNodeQueryKey(options)
+  });
+};
+const configureByContextProductQueryKey = (options) => [createQueryKey("configureByContextProduct", options)];
+const configureByContextProductOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await configureByContextProduct({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: configureByContextProductQueryKey(options)
+  });
+};
+const configureByContextProductMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await configureByContextProduct({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getCatalogsQueryKey = (options) => [
+  createQueryKey("getCatalogs", options)
+];
+const getCatalogsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getCatalogs({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getCatalogsQueryKey(options)
+  });
+};
+const createCatalogQueryKey = (options) => [
+  createQueryKey("createCatalog", options)
+];
+const createCatalogOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createCatalog({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createCatalogQueryKey(options)
+  });
+};
+const createCatalogMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createCatalog({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteCatalogByIdMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteCatalogById({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getCatalogByIdQueryKey = (options) => [createQueryKey("getCatalogById", options)];
+const getCatalogByIdOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getCatalogById({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getCatalogByIdQueryKey(options)
+  });
+};
+const updateCatalogMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateCatalog({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteReleasesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteReleases({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getReleasesQueryKey = (options) => [
+  createQueryKey("getReleases", options)
+];
+const getReleasesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getReleases({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getReleasesQueryKey(options)
+  });
+};
+const publishReleaseQueryKey = (options) => [createQueryKey("publishRelease", options)];
+const publishReleaseOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await publishRelease({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: publishReleaseQueryKey(options)
+  });
+};
+const publishReleaseMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await publishRelease({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteReleaseByIdMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteReleaseById({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getReleaseByIdQueryKey = (options) => [createQueryKey("getReleaseById", options)];
+const getReleaseByIdOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getReleaseById({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getReleaseByIdQueryKey(options)
+  });
+};
+const getRulesQueryKey = (options) => [
+  createQueryKey("getRules", options)
+];
+const getRulesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getRules({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getRulesQueryKey(options)
+  });
+};
+const createRuleQueryKey = (options) => [
+  createQueryKey("createRule", options)
+];
+const createRuleOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createRule({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createRuleQueryKey(options)
+  });
+};
+const createRuleMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createRule({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteRuleByIdMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteRuleById({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getRuleByIdQueryKey = (options) => [
+  createQueryKey("getRuleById", options)
+];
+const getRuleByIdOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getRuleById({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getRuleByIdQueryKey(options)
+  });
+};
+const updateRuleMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateRule({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getAllHierarchiesQueryKey = (options) => [createQueryKey("getAllHierarchies", options)];
+const getAllHierarchiesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAllHierarchies({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAllHierarchiesQueryKey(options)
+  });
+};
+const getHierarchyQueryKey = (options) => [
+  createQueryKey("getHierarchy", options)
+];
+const getHierarchyOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getHierarchy({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getHierarchyQueryKey(options)
+  });
+};
+const getHierarchyNodesQueryKey = (options) => [createQueryKey("getHierarchyNodes", options)];
+const getHierarchyNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getHierarchyNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getHierarchyNodesQueryKey(options)
+  });
+};
+const getHierarchyChildNodesQueryKey = (options) => [createQueryKey("getHierarchyChildNodes", options)];
+const getHierarchyChildNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getHierarchyChildNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getHierarchyChildNodesQueryKey(options)
+  });
+};
+const getAllNodesQueryKey = (options) => [
+  createQueryKey("getAllNodes", options)
+];
+const getAllNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAllNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAllNodesQueryKey(options)
+  });
+};
+const getNodeQueryKey = (options) => [
+  createQueryKey("getNode", options)
+];
+const getNodeOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getNode({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getNodeQueryKey(options)
+  });
+};
+const getChildNodesQueryKey = (options) => [
+  createQueryKey("getChildNodes", options)
+];
+const getChildNodesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getChildNodes({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getChildNodesQueryKey(options)
+  });
+};
+const getAllProductsQueryKey = (options) => [createQueryKey("getAllProducts", options)];
+const getAllProductsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAllProducts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAllProductsQueryKey(options)
+  });
+};
+const getProductQueryKey = (options) => [
+  createQueryKey("getProduct", options)
+];
+const getProductOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getProduct({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getProductQueryKey(options)
+  });
+};
+const getComponentProductIdsQueryKey = (options) => [createQueryKey("getComponentProductIds", options)];
+const getComponentProductIdsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getComponentProductIds({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getComponentProductIdsQueryKey(options)
+  });
+};
+const getChildProductsQueryKey = (options) => [createQueryKey("getChildProducts", options)];
+const getChildProductsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getChildProducts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getChildProductsQueryKey(options)
+  });
+};
+const getProductsForHierarchyQueryKey = (options) => [createQueryKey("getProductsForHierarchy", options)];
+const getProductsForHierarchyOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getProductsForHierarchy({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getProductsForHierarchyQueryKey(options)
+  });
+};
+const getProductsForNodeQueryKey = (options) => [createQueryKey("getProductsForNode", options)];
+const getProductsForNodeOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getProductsForNode({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getProductsForNodeQueryKey(options)
+  });
+};
+const getCartsQueryKey = (options) => [
+  createQueryKey("getCarts", options)
+];
+const getCartsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getCarts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getCartsQueryKey(options)
+  });
+};
+const createACartQueryKey = (options) => [
+  createQueryKey("createACart", options)
+];
+const createACartOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createACart({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createACartQueryKey(options)
+  });
+};
+const createACartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createACart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteACartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteACart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getCartQueryKey = (options) => [
+  createQueryKey("getCart", options)
+];
+const getCartOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getCart({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getCartQueryKey(options)
+  });
+};
+const updateACartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateACart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteAllCartItemsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteAllCartItems({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getCartItemsQueryKey = (options) => [
+  createQueryKey("getCartItems", options)
+];
+const getCartItemsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getCartItems({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getCartItemsQueryKey(options)
+  });
+};
+const manageCartsQueryKey = (options) => [
+  createQueryKey("manageCarts", options)
+];
+const manageCartsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await manageCarts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: manageCartsQueryKey(options)
+  });
+};
+const manageCartsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await manageCarts({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const bulkUpdateItemsInCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await bulkUpdateItemsInCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteACartItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteACartItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const updateACartItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateACartItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteAccountCartAssociationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteAccountCartAssociation({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const createAccountCartAssociationQueryKey = (options) => [createQueryKey("createAccountCartAssociation", options)];
+const createAccountCartAssociationOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createAccountCartAssociation({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createAccountCartAssociationQueryKey(options)
+  });
+};
+const createAccountCartAssociationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createAccountCartAssociation({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteCustomerCartAssociationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteCustomerCartAssociation({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const createCustomerCartAssociationQueryKey = (options) => [createQueryKey("createCustomerCartAssociation", options)];
+const createCustomerCartAssociationOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createCustomerCartAssociation({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createCustomerCartAssociationQueryKey(options)
+  });
+};
+const createCustomerCartAssociationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createCustomerCartAssociation({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteAPromotionViaPromotionCodeMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteAPromotionViaPromotionCode({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const addTaxItemToCartQueryKey = (options) => [createQueryKey("addTaxItemToCart", options)];
+const addTaxItemToCartOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await addTaxItemToCart({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: addTaxItemToCartQueryKey(options)
+  });
+};
+const addTaxItemToCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await addTaxItemToCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const bulkDeleteTaxItemsFromCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await bulkDeleteTaxItemsFromCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const bulkAddTaxItemsToCartQueryKey = (options) => [createQueryKey("bulkAddTaxItemsToCart", options)];
+const bulkAddTaxItemsToCartOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await bulkAddTaxItemsToCart({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: bulkAddTaxItemsToCartQueryKey(options)
+  });
+};
+const bulkAddTaxItemsToCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await bulkAddTaxItemsToCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteATaxItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteATaxItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const updateATaxItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateATaxItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const bulkDeleteCustomDiscountsFromCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await bulkDeleteCustomDiscountsFromCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const bulkAddCustomDiscountsToCartQueryKey = (options) => [createQueryKey("bulkAddCustomDiscountsToCart", options)];
+const bulkAddCustomDiscountsToCartOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await bulkAddCustomDiscountsToCart({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: bulkAddCustomDiscountsToCartQueryKey(options)
+  });
+};
+const bulkAddCustomDiscountsToCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await bulkAddCustomDiscountsToCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteCustomDiscountFromCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteCustomDiscountFromCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const updateCustomDiscountForCartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateCustomDiscountForCart({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const addCustomDiscountToCartItemQueryKey = (options) => [createQueryKey("addCustomDiscountToCartItem", options)];
+const addCustomDiscountToCartItemOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await addCustomDiscountToCartItem({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: addCustomDiscountToCartItemQueryKey(options)
+  });
+};
+const addCustomDiscountToCartItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await addCustomDiscountToCartItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteCustomDiscountFromCartItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteCustomDiscountFromCartItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const updateCustomDiscountForCartItemMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateCustomDiscountForCartItem({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const createCartPaymentIntentQueryKey = (options) => [createQueryKey("createCartPaymentIntent", options)];
+const createCartPaymentIntentOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createCartPaymentIntent({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createCartPaymentIntentQueryKey(options)
+  });
+};
+const createCartPaymentIntentMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createCartPaymentIntent({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const checkoutApiQueryKey = (options) => [
+  createQueryKey("checkoutApi", options)
+];
+const checkoutApiOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await checkoutApi({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: checkoutApiQueryKey(options)
+  });
+};
+const checkoutApiMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await checkoutApi({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getCustomerOrdersQueryKey = (options) => [createQueryKey("getCustomerOrders", options)];
+const getCustomerOrdersOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getCustomerOrders({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getCustomerOrdersQueryKey(options)
+  });
+};
+const getAnOrderQueryKey = (options) => [
+  createQueryKey("getAnOrder", options)
+];
+const getAnOrderOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAnOrder({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAnOrderQueryKey(options)
+  });
+};
+const updateAnOrderMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await updateAnOrder({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getOrderItemsQueryKey = (options) => [
+  createQueryKey("getOrderItems", options)
+];
+const getOrderItemsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getOrderItems({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getOrderItemsQueryKey(options)
+  });
+};
+const anonymizeOrdersQueryKey = (options) => [createQueryKey("anonymizeOrders", options)];
+const anonymizeOrdersOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await anonymizeOrders({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: anonymizeOrdersQueryKey(options)
+  });
+};
+const anonymizeOrdersMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await anonymizeOrders({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const paymentSetupQueryKey = (options) => [
+  createQueryKey("paymentSetup", options)
+];
+const paymentSetupOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await paymentSetup({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: paymentSetupQueryKey(options)
+  });
+};
+const paymentSetupMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await paymentSetup({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const confirmPaymentQueryKey = (options) => [createQueryKey("confirmPayment", options)];
+const confirmPaymentOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await confirmPayment({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: confirmPaymentQueryKey(options)
+  });
+};
+const confirmPaymentMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await confirmPayment({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const captureATransactionQueryKey = (options) => [createQueryKey("captureATransaction", options)];
+const captureATransactionOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await captureATransaction({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: captureATransactionQueryKey(options)
+  });
+};
+const captureATransactionMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await captureATransaction({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const refundATransactionQueryKey = (options) => [createQueryKey("refundATransaction", options)];
+const refundATransactionOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await refundATransaction({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: refundATransactionQueryKey(options)
+  });
+};
+const refundATransactionMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await refundATransaction({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getOrderTransactionsQueryKey = (options) => [createQueryKey("getOrderTransactions", options)];
+const getOrderTransactionsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getOrderTransactions({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getOrderTransactionsQueryKey(options)
+  });
+};
+const getATransactionQueryKey = (options) => [createQueryKey("getATransaction", options)];
+const getATransactionOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getATransaction({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getATransactionQueryKey(options)
+  });
+};
+const cancelATransactionQueryKey = (options) => [createQueryKey("cancelATransaction", options)];
+const cancelATransactionOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await cancelATransaction({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: cancelATransactionQueryKey(options)
+  });
+};
+const cancelATransactionMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await cancelATransaction({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getSubscriptionProductQueryKey = (options) => [createQueryKey("getSubscriptionProduct", options)];
+const getSubscriptionProductOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getSubscriptionProduct({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getSubscriptionProductQueryKey(options)
+  });
+};
+const getPlanQueryKey = (options) => [
+  createQueryKey("getPlan", options)
+];
+const getPlanOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getPlan({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getPlanQueryKey(options)
+  });
+};
+const listOfferingsQueryKey = (options) => [
+  createQueryKey("listOfferings", options)
+];
+const listOfferingsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listOfferings({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listOfferingsQueryKey(options)
+  });
+};
+const getOfferingQueryKey = (options) => [
+  createQueryKey("getOffering", options)
+];
+const getOfferingOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getOffering({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getOfferingQueryKey(options)
+  });
+};
+const listOfferingPlansQueryKey = (options) => [createQueryKey("listOfferingPlans", options)];
+const listOfferingPlansOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listOfferingPlans({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listOfferingPlansQueryKey(options)
+  });
+};
+const listOfferingFeaturesQueryKey = (options) => [createQueryKey("listOfferingFeatures", options)];
+const listOfferingFeaturesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listOfferingFeatures({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listOfferingFeaturesQueryKey(options)
+  });
+};
+const listOfferingProductsQueryKey = (options) => [createQueryKey("listOfferingProducts", options)];
+const listOfferingProductsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listOfferingProducts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listOfferingProductsQueryKey(options)
+  });
+};
+const listSubscriptionsQueryKey = (options) => [createQueryKey("listSubscriptions", options)];
+const listSubscriptionsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listSubscriptions({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listSubscriptionsQueryKey(options)
+  });
+};
+const getSubscriptionQueryKey = (options) => [createQueryKey("getSubscription", options)];
+const getSubscriptionOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getSubscription({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getSubscriptionQueryKey(options)
+  });
+};
+const listSubscriptionProductsQueryKey = (options) => [createQueryKey("listSubscriptionProducts", options)];
+const listSubscriptionProductsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listSubscriptionProducts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listSubscriptionProductsQueryKey(options)
+  });
+};
+const listSubscriptionPlansQueryKey = (options) => [createQueryKey("listSubscriptionPlans", options)];
+const listSubscriptionPlansOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listSubscriptionPlans({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listSubscriptionPlansQueryKey(options)
+  });
+};
+const listSubscriptionStatesQueryKey = (options) => [createQueryKey("listSubscriptionStates", options)];
+const listSubscriptionStatesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listSubscriptionStates({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listSubscriptionStatesQueryKey(options)
+  });
+};
+const getSubscriptionStateQueryKey = (options) => [createQueryKey("getSubscriptionState", options)];
+const getSubscriptionStateOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getSubscriptionState({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getSubscriptionStateQueryKey(options)
+  });
+};
+const listSubscriptionInvoicesQueryKey = (options) => [createQueryKey("listSubscriptionInvoices", options)];
+const listSubscriptionInvoicesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listSubscriptionInvoices({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listSubscriptionInvoicesQueryKey(options)
+  });
+};
+const listSubscriptionInvoicePaymentsQueryKey = (options) => [createQueryKey("listSubscriptionInvoicePayments", options)];
+const listSubscriptionInvoicePaymentsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listSubscriptionInvoicePayments({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listSubscriptionInvoicePaymentsQueryKey(options)
+  });
+};
+const getSubscriptionInvoicePaymentQueryKey = (options) => [createQueryKey("getSubscriptionInvoicePayment", options)];
+const getSubscriptionInvoicePaymentOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getSubscriptionInvoicePayment({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getSubscriptionInvoicePaymentQueryKey(options)
+  });
+};
+const getSubscriptionInvoiceQueryKey = (options) => [createQueryKey("getSubscriptionInvoice", options)];
+const getSubscriptionInvoiceOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getSubscriptionInvoice({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getSubscriptionInvoiceQueryKey(options)
+  });
+};
+const listInvoicesQueryKey = (options) => [
+  createQueryKey("listInvoices", options)
+];
+const listInvoicesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listInvoices({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listInvoicesQueryKey(options)
+  });
+};
+const getInvoiceQueryKey = (options) => [
+  createQueryKey("getInvoice", options)
+];
+const getInvoiceOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getInvoice({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getInvoiceQueryKey(options)
+  });
+};
+const getFeatureQueryKey = (options) => [
+  createQueryKey("getFeature", options)
+];
+const getFeatureOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getFeature({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getFeatureQueryKey(options)
+  });
+};
+const getStockQueryKey = (options) => [
+  createQueryKey("getStock", options)
+];
+const getStockOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getStock({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getStockQueryKey(options)
+  });
+};
+const listLocationsQueryKey = (options) => [
+  createQueryKey("listLocations", options)
+];
+const listLocationsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await listLocations({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: listLocationsQueryKey(options)
+  });
+};
+const createAnAccessTokenQueryKey = (options) => [createQueryKey("createAnAccessToken", options)];
+const createAnAccessTokenOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await createAnAccessToken({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: createAnAccessTokenQueryKey(options)
+  });
+};
+const createAnAccessTokenMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await createAnAccessToken({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getV2AccountAddressesQueryKey = (options) => [createQueryKey("getV2AccountAddresses", options)];
+const getV2AccountAddressesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2AccountAddresses({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountAddressesQueryKey(options)
+  });
+};
+const postV2AccountAddressQueryKey = (options) => [createQueryKey("postV2AccountAddress", options)];
+const postV2AccountAddressOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await postV2AccountAddress({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: postV2AccountAddressQueryKey(options)
+  });
+};
+const postV2AccountAddressMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await postV2AccountAddress({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const deleteV2AccountAddressMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await deleteV2AccountAddress({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getV2AccountAddressQueryKey = (options) => [createQueryKey("getV2AccountAddress", options)];
+const getV2AccountAddressOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2AccountAddress({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountAddressQueryKey(options)
+  });
+};
+const putV2AccountAddressMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await putV2AccountAddress({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getV2AccountsQueryKey = (options) => [
+  createQueryKey("getV2Accounts", options)
+];
+const getV2AccountsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2Accounts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountsQueryKey(options)
+  });
+};
+const postV2AccountsQueryKey = (options) => [createQueryKey("postV2Accounts", options)];
+const postV2AccountsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await postV2Accounts({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: postV2AccountsQueryKey(options)
+  });
+};
+const postV2AccountsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await postV2Accounts({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getV2AccountsAccountIdQueryKey = (options) => [createQueryKey("getV2AccountsAccountId", options)];
+const getV2AccountsAccountIdOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2AccountsAccountId({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountsAccountIdQueryKey(options)
+  });
+};
+const putV2AccountsAccountIdMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await putV2AccountsAccountId({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getV2AccountMembersQueryKey = (options) => [createQueryKey("getV2AccountMembers", options)];
+const getV2AccountMembersOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2AccountMembers({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountMembersQueryKey(options)
+  });
+};
+const getV2AccountMembersAccountMemberIdQueryKey = (options) => [createQueryKey("getV2AccountMembersAccountMemberId", options)];
+const getV2AccountMembersAccountMemberIdOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2AccountMembersAccountMemberId({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountMembersAccountMemberIdQueryKey(options)
+  });
+};
+const getV2AccountsAccountIdAccountMembershipsQueryKey = (options) => [createQueryKey("getV2AccountsAccountIdAccountMemberships", options)];
+const getV2AccountsAccountIdAccountMembershipsOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getV2AccountsAccountIdAccountMemberships({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getV2AccountsAccountIdAccountMembershipsQueryKey(options)
+  });
+};
+const postV2AccountMembersTokensQueryKey = (options) => [createQueryKey("postV2AccountMembersTokens", options)];
+const postV2AccountMembersTokensOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await postV2AccountMembersTokens({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: postV2AccountMembersTokensQueryKey(options)
+  });
+};
+const postV2AccountMembersTokensMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (localOptions) => {
+      const { data } = await postV2AccountMembersTokens({
+        ...options,
+        ...localOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+const getAllCurrenciesQueryKey = (options) => [createQueryKey("getAllCurrencies", options)];
+const getAllCurrenciesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAllCurrencies({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAllCurrenciesQueryKey(options)
+  });
+};
+const getACurrencyQueryKey = (options) => [
+  createQueryKey("getACurrency", options)
+];
+const getACurrencyOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getACurrency({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getACurrencyQueryKey(options)
+  });
+};
+const getAllFilesQueryKey = (options) => [
+  createQueryKey("getAllFiles", options)
+];
+const getAllFilesOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAllFiles({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAllFilesQueryKey(options)
+  });
+};
+const getAFileQueryKey = (options) => [
+  createQueryKey("getAFile", options)
+];
+const getAFileOptions = (options) => {
+  return queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+      const { data } = await getAFile({
+        ...options,
+        ...queryKey[0],
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getAFileQueryKey(options)
+  });
+};
+export {
+  addCustomDiscountToCartItemMutation,
+  addCustomDiscountToCartItemOptions,
+  addCustomDiscountToCartItemQueryKey,
+  addTaxItemToCartMutation,
+  addTaxItemToCartOptions,
+  addTaxItemToCartQueryKey,
+  anonymizeOrdersMutation,
+  anonymizeOrdersOptions,
+  anonymizeOrdersQueryKey,
+  bulkAddCustomDiscountsToCartMutation,
+  bulkAddCustomDiscountsToCartOptions,
+  bulkAddCustomDiscountsToCartQueryKey,
+  bulkAddTaxItemsToCartMutation,
+  bulkAddTaxItemsToCartOptions,
+  bulkAddTaxItemsToCartQueryKey,
+  bulkDeleteCustomDiscountsFromCartMutation,
+  bulkDeleteTaxItemsFromCartMutation,
+  bulkUpdateItemsInCartMutation,
+  cancelATransactionMutation,
+  cancelATransactionOptions,
+  cancelATransactionQueryKey,
+  captureATransactionMutation,
+  captureATransactionOptions,
+  captureATransactionQueryKey,
+  checkoutApiMutation,
+  checkoutApiOptions,
+  checkoutApiQueryKey,
+  configureByContextProductMutation,
+  configureByContextProductOptions,
+  configureByContextProductQueryKey,
+  confirmPaymentMutation,
+  confirmPaymentOptions,
+  confirmPaymentQueryKey,
+  createACartMutation,
+  createACartOptions,
+  createACartQueryKey,
+  createAccountCartAssociationMutation,
+  createAccountCartAssociationOptions,
+  createAccountCartAssociationQueryKey,
+  createAnAccessTokenMutation,
+  createAnAccessTokenOptions,
+  createAnAccessTokenQueryKey,
+  createCartPaymentIntentMutation,
+  createCartPaymentIntentOptions,
+  createCartPaymentIntentQueryKey,
+  createCatalogMutation,
+  createCatalogOptions,
+  createCatalogQueryKey,
+  createCustomerCartAssociationMutation,
+  createCustomerCartAssociationOptions,
+  createCustomerCartAssociationQueryKey,
+  createRuleMutation,
+  createRuleOptions,
+  createRuleQueryKey,
+  deleteACartItemMutation,
+  deleteACartMutation,
+  deleteAPromotionViaPromotionCodeMutation,
+  deleteATaxItemMutation,
+  deleteAccountCartAssociationMutation,
+  deleteAllCartItemsMutation,
+  deleteCatalogByIdMutation,
+  deleteCustomDiscountFromCartItemMutation,
+  deleteCustomDiscountFromCartMutation,
+  deleteCustomerCartAssociationMutation,
+  deleteReleaseByIdMutation,
+  deleteReleasesMutation,
+  deleteRuleByIdMutation,
+  deleteV2AccountAddressMutation,
+  getACurrencyOptions,
+  getACurrencyQueryKey,
+  getAFileOptions,
+  getAFileQueryKey,
+  getATransactionOptions,
+  getATransactionQueryKey,
+  getAllCurrenciesOptions,
+  getAllCurrenciesQueryKey,
+  getAllFilesOptions,
+  getAllFilesQueryKey,
+  getAllHierarchiesOptions,
+  getAllHierarchiesQueryKey,
+  getAllNodesOptions,
+  getAllNodesQueryKey,
+  getAllProductsOptions,
+  getAllProductsQueryKey,
+  getAnOrderOptions,
+  getAnOrderQueryKey,
+  getByContextAllHierarchiesOptions,
+  getByContextAllHierarchiesQueryKey,
+  getByContextAllNodesOptions,
+  getByContextAllNodesQueryKey,
+  getByContextAllProductsOptions,
+  getByContextAllProductsQueryKey,
+  getByContextChildNodesOptions,
+  getByContextChildNodesQueryKey,
+  getByContextChildProductsOptions,
+  getByContextChildProductsQueryKey,
+  getByContextComponentProductIdsOptions,
+  getByContextComponentProductIdsQueryKey,
+  getByContextHierarchyChildNodesOptions,
+  getByContextHierarchyChildNodesQueryKey,
+  getByContextHierarchyNodesOptions,
+  getByContextHierarchyNodesQueryKey,
+  getByContextHierarchyOptions,
+  getByContextHierarchyQueryKey,
+  getByContextNodeOptions,
+  getByContextNodeQueryKey,
+  getByContextProductOptions,
+  getByContextProductQueryKey,
+  getByContextProductsForHierarchyOptions,
+  getByContextProductsForHierarchyQueryKey,
+  getByContextProductsForNodeOptions,
+  getByContextProductsForNodeQueryKey,
+  getByContextReleaseOptions,
+  getByContextReleaseQueryKey,
+  getCartItemsOptions,
+  getCartItemsQueryKey,
+  getCartOptions,
+  getCartQueryKey,
+  getCartsOptions,
+  getCartsQueryKey,
+  getCatalogByIdOptions,
+  getCatalogByIdQueryKey,
+  getCatalogsOptions,
+  getCatalogsQueryKey,
+  getChildNodesOptions,
+  getChildNodesQueryKey,
+  getChildProductsOptions,
+  getChildProductsQueryKey,
+  getComponentProductIdsOptions,
+  getComponentProductIdsQueryKey,
+  getCustomerOrdersOptions,
+  getCustomerOrdersQueryKey,
+  getFeatureOptions,
+  getFeatureQueryKey,
+  getHierarchyChildNodesOptions,
+  getHierarchyChildNodesQueryKey,
+  getHierarchyNodesOptions,
+  getHierarchyNodesQueryKey,
+  getHierarchyOptions,
+  getHierarchyQueryKey,
+  getInvoiceOptions,
+  getInvoiceQueryKey,
+  getNodeOptions,
+  getNodeQueryKey,
+  getOfferingOptions,
+  getOfferingQueryKey,
+  getOrderItemsOptions,
+  getOrderItemsQueryKey,
+  getOrderTransactionsOptions,
+  getOrderTransactionsQueryKey,
+  getPlanOptions,
+  getPlanQueryKey,
+  getProductOptions,
+  getProductQueryKey,
+  getProductsForHierarchyOptions,
+  getProductsForHierarchyQueryKey,
+  getProductsForNodeOptions,
+  getProductsForNodeQueryKey,
+  getReleaseByIdOptions,
+  getReleaseByIdQueryKey,
+  getReleasesOptions,
+  getReleasesQueryKey,
+  getRuleByIdOptions,
+  getRuleByIdQueryKey,
+  getRulesOptions,
+  getRulesQueryKey,
+  getStockOptions,
+  getStockQueryKey,
+  getSubscriptionInvoiceOptions,
+  getSubscriptionInvoicePaymentOptions,
+  getSubscriptionInvoicePaymentQueryKey,
+  getSubscriptionInvoiceQueryKey,
+  getSubscriptionOptions,
+  getSubscriptionProductOptions,
+  getSubscriptionProductQueryKey,
+  getSubscriptionQueryKey,
+  getSubscriptionStateOptions,
+  getSubscriptionStateQueryKey,
+  getV2AccountAddressOptions,
+  getV2AccountAddressQueryKey,
+  getV2AccountAddressesOptions,
+  getV2AccountAddressesQueryKey,
+  getV2AccountMembersAccountMemberIdOptions,
+  getV2AccountMembersAccountMemberIdQueryKey,
+  getV2AccountMembersOptions,
+  getV2AccountMembersQueryKey,
+  getV2AccountsAccountIdAccountMembershipsOptions,
+  getV2AccountsAccountIdAccountMembershipsQueryKey,
+  getV2AccountsAccountIdOptions,
+  getV2AccountsAccountIdQueryKey,
+  getV2AccountsOptions,
+  getV2AccountsQueryKey,
+  listInvoicesOptions,
+  listInvoicesQueryKey,
+  listLocationsOptions,
+  listLocationsQueryKey,
+  listOfferingFeaturesOptions,
+  listOfferingFeaturesQueryKey,
+  listOfferingPlansOptions,
+  listOfferingPlansQueryKey,
+  listOfferingProductsOptions,
+  listOfferingProductsQueryKey,
+  listOfferingsOptions,
+  listOfferingsQueryKey,
+  listSubscriptionInvoicePaymentsOptions,
+  listSubscriptionInvoicePaymentsQueryKey,
+  listSubscriptionInvoicesOptions,
+  listSubscriptionInvoicesQueryKey,
+  listSubscriptionPlansOptions,
+  listSubscriptionPlansQueryKey,
+  listSubscriptionProductsOptions,
+  listSubscriptionProductsQueryKey,
+  listSubscriptionStatesOptions,
+  listSubscriptionStatesQueryKey,
+  listSubscriptionsOptions,
+  listSubscriptionsQueryKey,
+  manageCartsMutation,
+  manageCartsOptions,
+  manageCartsQueryKey,
+  paymentSetupMutation,
+  paymentSetupOptions,
+  paymentSetupQueryKey,
+  postV2AccountAddressMutation,
+  postV2AccountAddressOptions,
+  postV2AccountAddressQueryKey,
+  postV2AccountMembersTokensMutation,
+  postV2AccountMembersTokensOptions,
+  postV2AccountMembersTokensQueryKey,
+  postV2AccountsMutation,
+  postV2AccountsOptions,
+  postV2AccountsQueryKey,
+  publishReleaseMutation,
+  publishReleaseOptions,
+  publishReleaseQueryKey,
+  putV2AccountAddressMutation,
+  putV2AccountsAccountIdMutation,
+  refundATransactionMutation,
+  refundATransactionOptions,
+  refundATransactionQueryKey,
+  updateACartItemMutation,
+  updateACartMutation,
+  updateATaxItemMutation,
+  updateAnOrderMutation,
+  updateCatalogMutation,
+  updateCustomDiscountForCartItemMutation,
+  updateCustomDiscountForCartMutation,
+  updateRuleMutation
+};
+//# sourceMappingURL=react-query.gen.mjs.map