@viu/emporix-sdk-react 1.0.0

package/dist/hooks.cjs

@@ -0,0 +1,1212 @@
+'use strict';
+
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var emporixSdk = require('@viu/emporix-sdk');
+require('react/jsx-runtime');
+
+// src/hooks/use-customer-session.ts
+var NULL_CTX = {
+  activeCompany: null,
+  myCompanies: [],
+  mode: "b2c",
+  status: "idle",
+  error: null,
+  setActiveCompany: async () => {
+    throw new Error("CompanyContextProvider not mounted");
+  },
+  refetchMyCompanies: async () => {
+  }
+};
+var EmporixCompanyContext = react.createContext(NULL_CTX);
+function useActiveCompany() {
+  return react.useContext(EmporixCompanyContext);
+}
+var EmporixContext = react.createContext(null);
+var EmporixSiteContext = react.createContext(null);
+function useEmporix() {
+  const ctx = react.useContext(EmporixContext);
+  if (!ctx) throw new Error("useEmporix must be used within an EmporixProvider");
+  return ctx;
+}
+
+// src/hooks/internal/bootstrap-cart.ts
+async function bootstrapCart(opts) {
+  return opts.qc.fetchQuery({
+    queryKey: [
+      "emporix",
+      "cart-bootstrap",
+      {
+        tenant: opts.client.tenant,
+        // ctx.kind is the discriminator of AuthContext — same string as the
+        // legacy `authKind` param, derived directly so callers can't drift.
+        authKind: opts.ctx.kind,
+        siteCode: opts.siteCode,
+        ...opts.type !== void 0 ? { type: opts.type } : {},
+        ...opts.legalEntityId !== void 0 ? { legalEntityId: opts.legalEntityId } : {}
+      }
+    ],
+    queryFn: () => opts.client.carts.getCurrent(opts.ctx, {
+      siteCode: opts.siteCode,
+      ...opts.type !== void 0 ? { type: opts.type } : {},
+      ...opts.legalEntityId !== void 0 ? { legalEntityId: opts.legalEntityId } : {},
+      create: true
+    }),
+    staleTime: Infinity
+  });
+}
+
+// src/hooks/use-customer-session.ts
+var EMPTY_SESSION = {
+  token: null,
+  refreshToken: null,
+  saasToken: null
+};
+function useCustomerSession() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const siteCtx = react.useContext(EmporixSiteContext);
+  const [session, setSession] = react.useState(() => ({
+    token: storage.getCustomerToken(),
+    refreshToken: null,
+    saasToken: null
+  }));
+  react.useEffect(() => {
+    return storage.subscribe?.((t) => setSession((s) => ({ ...s, token: t })));
+  }, [storage]);
+  const meQuery = reactQuery.useQuery({
+    queryKey: ["emporix", "customer", "me", { tenant: client.tenant, hasToken: session.token !== null }],
+    enabled: session.token !== null,
+    queryFn: () => client.customers.me(emporixSdk.auth.customer(session.token)),
+    // 30s — matches Balanced default. Lets honourPreferredSite's fetchQuery
+    // (with staleTime: Infinity) reuse the cache instead of refetching.
+    staleTime: 3e4
+  });
+  const login = react.useCallback(
+    async (input) => {
+      const result = await client.customers.login(input);
+      storage.setCustomerToken(result.customerToken);
+      storage.setRefreshToken(result.refreshToken || null);
+      setSession({
+        token: result.customerToken,
+        refreshToken: result.refreshToken || null,
+        saasToken: result.saasToken || null
+      });
+      await onboardCustomerCart({
+        qc,
+        client,
+        storage,
+        customerToken: result.customerToken
+      });
+      await honourPreferredSite({
+        qc,
+        client,
+        customerToken: result.customerToken,
+        siteCtx
+      });
+      await qc.invalidateQueries({ queryKey: ["emporix", "customer"], refetchType: "none" });
+      await qc.invalidateQueries({ queryKey: ["emporix", "cart"], refetchType: "none" });
+    },
+    [client, storage, qc, siteCtx]
+  );
+  const signup = react.useCallback(
+    async (input) => {
+      await client.customers.signup(input);
+    },
+    [client]
+  );
+  const applySession = react.useCallback(
+    async (incoming) => {
+      storage.setCustomerToken(incoming.customerToken);
+      storage.setRefreshToken(incoming.refreshToken || null);
+      setSession({
+        token: incoming.customerToken,
+        refreshToken: incoming.refreshToken || null,
+        saasToken: incoming.saasToken || null
+      });
+      await onboardCustomerCart({
+        qc,
+        client,
+        storage,
+        customerToken: incoming.customerToken
+      });
+      await honourPreferredSite({
+        qc,
+        client,
+        customerToken: incoming.customerToken,
+        siteCtx
+      });
+      await qc.invalidateQueries({ queryKey: ["emporix", "customer"], refetchType: "none" });
+      await qc.invalidateQueries({ queryKey: ["emporix", "cart"], refetchType: "none" });
+    },
+    [client, storage, qc, siteCtx]
+  );
+  const socialLogin = react.useCallback(
+    async (input) => {
+      await applySession(await client.customers.socialLogin(input));
+    },
+    [client, applySession]
+  );
+  const exchangeToken = react.useCallback(
+    async (input) => {
+      await applySession(await client.customers.exchangeToken(input));
+    },
+    [client, applySession]
+  );
+  const logout = react.useCallback(async () => {
+    if (session.token) {
+      try {
+        await client.customers.logout(emporixSdk.auth.customer(session.token));
+      } catch {
+      }
+    }
+    storage.setCustomerToken(null);
+    storage.setRefreshToken(null);
+    storage.setActiveLegalEntityId(null);
+    setSession(EMPTY_SESSION);
+    qc.removeQueries({ queryKey: ["emporix", "customer"] });
+    qc.removeQueries({ queryKey: ["emporix", "cart"] });
+  }, [client, session.token, storage, qc]);
+  const refresh = react.useCallback(async () => {
+    await meQuery.refetch();
+  }, [meQuery]);
+  const refreshSession = react.useCallback(async () => {
+    if (!session.refreshToken) return;
+    const refreshed = await client.customers.refresh({
+      refreshToken: session.refreshToken,
+      ...session.saasToken ? { saasToken: session.saasToken } : {}
+    });
+    storage.setCustomerToken(refreshed.customerToken);
+    if (refreshed.refreshToken) storage.setRefreshToken(refreshed.refreshToken);
+    setSession((s) => ({
+      token: refreshed.customerToken,
+      refreshToken: refreshed.refreshToken || s.refreshToken,
+      saasToken: refreshed.saasToken || s.saasToken
+    }));
+    await qc.invalidateQueries({ queryKey: ["emporix", "customer"] });
+    await qc.invalidateQueries({ queryKey: ["emporix", "cart"] });
+  }, [client, storage, qc, session.refreshToken, session.saasToken]);
+  return {
+    customerToken: session.token,
+    refreshToken: session.refreshToken,
+    customer: meQuery.data ?? null,
+    isAuthenticated: session.token !== null,
+    isLoading: meQuery.isLoading && session.token !== null,
+    login,
+    signup,
+    socialLogin,
+    exchangeToken,
+    logout,
+    refresh,
+    refreshSession
+  };
+}
+async function honourPreferredSite(opts) {
+  const { qc, client, customerToken, siteCtx } = opts;
+  if (!siteCtx) return;
+  try {
+    const me = await qc.fetchQuery({
+      queryKey: [
+        "emporix",
+        "customer",
+        "me",
+        { tenant: client.tenant, hasToken: true }
+      ],
+      queryFn: () => client.customers.me(emporixSdk.auth.customer(customerToken)),
+      // Reuse whatever meQuery already wrote (login flow runs meQuery in
+      // parallel). Without this, fetchQuery refetches if meQuery's data is
+      // already stale (default staleTime: 0 on meQuery).
+      staleTime: Infinity
+    });
+    const preferred = me.preferredSite;
+    if (preferred && siteCtx.siteCode !== preferred) {
+      await siteCtx.setSite(preferred);
+    }
+  } catch {
+  }
+}
+async function onboardCustomerCart(opts) {
+  const { qc, client, storage, customerToken } = opts;
+  const siteCode = client.config?.credentials?.storefront?.context?.siteCode;
+  if (!siteCode) return;
+  const ctx = emporixSdk.auth.customer(customerToken);
+  try {
+    const customerCart = await bootstrapCart({
+      qc,
+      client,
+      ctx,
+      siteCode
+    });
+    const customerCartId = customerCart?.id;
+    if (!customerCartId) return;
+    const anonCartId = storage.getCartId();
+    if (anonCartId && anonCartId !== customerCartId) {
+      await client.carts.merge(customerCartId, [anonCartId], ctx);
+    }
+    storage.setCartId(customerCartId);
+  } catch {
+  }
+}
+function useReadAuth(override) {
+  const { storage } = useEmporix();
+  if (override) return { ctx: override };
+  const token = storage.getCustomerToken();
+  return token ? { ctx: emporixSdk.auth.customer(token) } : { ctx: emporixSdk.auth.anonymous() };
+}
+function useCustomerOnlyCtx() {
+  const { storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  if (!token) {
+    throw new Error("Requires a logged-in customer (no token in storage)");
+  }
+  return emporixSdk.auth.customer(token);
+}
+function useReadSite() {
+  const ctx = react.useContext(EmporixSiteContext);
+  return { siteCode: ctx?.siteCode ?? null };
+}
+
+// src/hooks/internal/query-keys.ts
+function emporixKey(resource, args, context) {
+  const meta = {
+    tenant: context.tenant,
+    authKind: context.authKind
+  };
+  if (context.siteCode !== void 0) {
+    meta.siteCode = context.siteCode;
+  }
+  return ["emporix", resource, ...args, meta];
+}
+function useEmporixInfinite(opts) {
+  return reactQuery.useInfiniteQuery({
+    queryKey: opts.queryKey,
+    initialPageParam: 1,
+    queryFn: ({ pageParam }) => opts.fetchPage(pageParam),
+    getNextPageParam: (last) => last.hasNextPage ? last.pageNumber + 1 : void 0,
+    ...opts.enabled !== void 0 ? { enabled: opts.enabled } : {},
+    ...opts.staleTime !== void 0 ? { staleTime: opts.staleTime } : {}
+  });
+}
+
+// src/hooks/use-products.ts
+var PRODUCTS_STALE_TIME = 6e4;
+function useProduct(productId, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("product", [productId], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.products.get(productId, void 0, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProducts(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("products", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.products.list(params, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProductsInfinite(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: emporixKey("products-infinite", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    fetchPage: (pageNumber) => client.products.list(
+      params.pageSize !== void 0 ? { pageNumber, pageSize: params.pageSize } : { pageNumber },
+      ctx
+    ),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProductByCode(code, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("product-by-code", [code], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof code === "string" && code !== "",
+    queryFn: () => client.products.getByCode(code, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProductSearch(query, params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("product-search", [query, params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof query === "string" && query.trim() !== "",
+    queryFn: () => client.products.search(query, params, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+var CATEGORIES_STALE_TIME = 5 * 6e4;
+function useCategory(categoryId, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("category", [categoryId], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.categories.get(categoryId, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCategories(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("categories", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.categories.list(params, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCategoriesInfinite(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: emporixKey("categories-infinite", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    fetchPage: (pageNumber) => client.categories.list(
+      params.pageSize !== void 0 ? { pageNumber, pageSize: params.pageSize } : { pageNumber },
+      ctx
+    ),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCategoryTree(rootId, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("category-tree", [rootId ?? null], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.categories.tree(rootId, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useProductsInCategory(categoryId, params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("products-in-category", [categoryId, params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof categoryId === "string" && categoryId !== "",
+    queryFn: () => client.categories.productsIn(categoryId, params, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useProductsInCategoryInfinite(categoryId, params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: emporixKey("products-in-category-infinite", [categoryId, params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof categoryId === "string" && categoryId !== "",
+    fetchPage: (pageNumber) => client.categories.productsIn(
+      categoryId,
+      params.pageSize !== void 0 ? { pageNumber, pageSize: params.pageSize } : { pageNumber },
+      ctx
+    ),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCart(cartId, options = {}) {
+  const { client, storage } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  const resolvedId = cartId ?? storage.getCartId() ?? void 0;
+  return reactQuery.useQuery({
+    queryKey: emporixKey(
+      "cart",
+      [resolvedId ?? null, activeCompany?.id ?? null],
+      { tenant: client.tenant, authKind: ctx.kind, siteCode }
+    ),
+    enabled: resolvedId !== void 0,
+    queryFn: () => client.carts.get(resolvedId, ctx)
+  });
+}
+function useCartMutations(cartId) {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const { ctx } = useReadAuth();
+  const { siteCode } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  const resolveId = () => {
+    const id = cartId ?? storage.getCartId();
+    if (!id) {
+      throw new emporixSdk.EmporixError(
+        "useCartMutations: no cartId available \u2014 pass one explicitly or call useActiveCart({ create: true }) first"
+      );
+    }
+    return id;
+  };
+  const keyFor = (id) => emporixKey(
+    "cart",
+    [id, activeCompany?.id ?? null],
+    { tenant: client.tenant, authKind: ctx.kind, siteCode }
+  );
+  function make(run, optimistic) {
+    return reactQuery.useMutation({
+      mutationFn: async (vars) => run(resolveId(), vars),
+      onMutate: async (vars) => {
+        const id = resolveId();
+        const key = keyFor(id);
+        await qc.cancelQueries({ queryKey: key });
+        const previous = qc.getQueryData(key);
+        if (optimistic) qc.setQueryData(key, optimistic(previous, vars));
+        return { previous, key };
+      },
+      onError: (_e, _v, c) => {
+        if (c) qc.setQueryData(c.key, c.previous);
+      },
+      onSuccess: (cart, _v, c) => {
+        if (c) qc.setQueryData(c.key, cart);
+      }
+    });
+  }
+  return {
+    addItem: make(
+      (id, v) => client.carts.addItem(id, v, ctx),
+      (prev, v) => prev ? {
+        ...prev,
+        // Optimistic placeholder; replaced by the real item on success.
+        items: [
+          ...prev.items ?? [],
+          {
+            id: `optimistic-${v.product?.id ?? "item"}`,
+            ...v
+          }
+        ]
+      } : prev
+    ),
+    updateItem: make((id, v) => client.carts.updateItem(id, v.itemId, v.patch, ctx)),
+    removeItem: make(
+      (id, v) => client.carts.removeItem(id, v.itemId, ctx),
+      (prev, v) => prev ? { ...prev, items: (prev.items ?? []).filter((i) => i.id !== v.itemId) } : prev
+    ),
+    clear: make(
+      (id) => client.carts.clear(id, ctx),
+      (prev) => prev ? { ...prev, items: [] } : prev
+    ),
+    applyCoupon: make((id, v) => client.carts.applyCoupon(id, v.code, ctx)),
+    removeCoupon: make((id, v) => client.carts.removeCoupon(id, v.code, ctx)),
+    setShippingAddress: make((id, v) => client.carts.setShippingAddress(id, v, ctx)),
+    setBillingAddress: make((id, v) => client.carts.setBillingAddress(id, v, ctx))
+  };
+}
+function useCreateCart() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const { ctx } = useReadAuth();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.carts.create(input, ctx),
+    onSuccess: async (cart) => {
+      if (cart.cartId) storage.setCartId(cart.cartId);
+      await qc.invalidateQueries({ queryKey: ["emporix", "cart"] });
+    }
+  });
+}
+function useActiveCart(opts) {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const { ctx } = useReadAuth(opts?.auth);
+  const { siteCode: activeSite } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  const [cartId, setCartId] = react.useState(() => storage.getCartId());
+  const effectiveLegalEntityId = opts?.legalEntityId ?? activeCompany?.id;
+  react.useEffect(() => {
+    if (cartId !== null) return;
+    if (!opts?.create) return;
+    const siteCode = activeSite ?? client.config?.credentials?.storefront?.context?.siteCode;
+    if (!siteCode) return;
+    let cancelled = false;
+    bootstrapCart({
+      qc,
+      client,
+      ctx,
+      siteCode,
+      ...opts.type !== void 0 ? { type: opts.type } : {},
+      ...effectiveLegalEntityId !== void 0 ? { legalEntityId: effectiveLegalEntityId } : {}
+    }).then((cart) => {
+      if (cancelled) return;
+      if (cart?.id) {
+        storage.setCartId(cart.id);
+        setCartId(cart.id);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [cartId, opts?.create, opts?.type, effectiveLegalEntityId, ctx.kind, activeSite]);
+  const inner = useCart(cartId ?? void 0, opts?.auth ? { auth: opts.auth } : {});
+  const data = cartId === null ? null : inner.data;
+  return { ...inner, data };
+}
+var PAYMENT_MODES_STALE_TIME = 10 * 6e4;
+function customerOnlyCtx(token) {
+  if (!token) throw new Error("usePaymentModes requires a logged-in customer token");
+  return emporixSdk.auth.customer(token);
+}
+function useCheckout() {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth();
+  const { activeCompany } = useActiveCompany();
+  const withLE = (input) => {
+    if (!activeCompany?.id) return input;
+    if ("legalEntityId" in input) return input;
+    return { ...input, legalEntityId: activeCompany.id };
+  };
+  const placeOrder = reactQuery.useMutation({
+    mutationFn: (v) => client.checkout.placeOrder(withLE(v.input), ctx, {
+      ...v.saasToken !== void 0 ? { saasToken: v.saasToken } : {},
+      ...v.siteCode !== void 0 ? { siteCode: v.siteCode } : {}
+    })
+  });
+  const placeOrderFromQuote = reactQuery.useMutation({
+    mutationFn: (v) => client.checkout.placeOrderFromQuote(withLE(v.input), ctx, {
+      ...v.saasToken !== void 0 ? { saasToken: v.saasToken } : {},
+      ...v.siteCode !== void 0 ? { siteCode: v.siteCode } : {}
+    })
+  });
+  return { placeOrder, placeOrderFromQuote };
+}
+function usePaymentModes(options = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  return reactQuery.useQuery({
+    queryKey: emporixKey(
+      "payment-modes",
+      [activeCompany?.id ?? null],
+      { tenant: client.tenant, authKind: "customer", siteCode }
+    ),
+    enabled: (options.enabled ?? true) && token !== null,
+    queryFn: () => client.payments.listPaymentModes(customerOnlyCtx(token)),
+    staleTime: PAYMENT_MODES_STALE_TIME
+  });
+}
+var PRICES_STALE_TIME = 6e4;
+function useMatchPrices(input, options = {}) {
+  const { client } = useEmporix();
+  const { siteCode } = useReadSite();
+  const ctx = options.customerToken ? emporixSdk.auth.customer(options.customerToken) : emporixSdk.auth.anonymous();
+  return reactQuery.useQuery({
+    queryKey: [
+      "emporix",
+      "match-prices",
+      { tenant: client.tenant, input, anon: !options.customerToken, siteCode }
+    ],
+    enabled: (options.enabled ?? true) && (input.items?.length ?? 0) > 0,
+    queryFn: () => client.prices.matchByContext(input, ctx),
+    staleTime: PRICES_STALE_TIME
+  });
+}
+
+// src/hooks/use-product-media.ts
+function useProductMedia(productId) {
+  const q = useProduct(productId);
+  const data = q.data?.productMedia;
+  return { data, isLoading: q.isLoading, error: q.error };
+}
+var SEGMENTS_STALE_TIME = 5 * 6e4;
+function customerCtx(token) {
+  if (!token) throw new Error("requires a customer token in storage");
+  return emporixSdk.auth.customer(token);
+}
+function useMySegments(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "list", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.list(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentItems(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "items", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.listItems(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentCategoryTree(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "categoryTree", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.getCategoryTree(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentProducts(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "myProducts", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.listMyProducts(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentProductsInfinite(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: [
+      "emporix",
+      "segment",
+      "myProductsInfinite",
+      { tenant: client.tenant, query, siteCode }
+    ],
+    enabled: token !== null,
+    fetchPage: (pageNumber) => client.segments.listMyProducts(
+      { ...query, pageNumber, pageSize: query.pageSize ?? 20 },
+      customerCtx(token)
+    ),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentCategories(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "myCategories", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.listMyCategories(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentCategoriesInfinite(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: [
+      "emporix",
+      "segment",
+      "myCategoriesInfinite",
+      { tenant: client.tenant, query, siteCode }
+    ],
+    enabled: token !== null,
+    fetchPage: (pageNumber) => client.segments.listMyCategories(
+      { ...query, pageNumber, pageSize: query.pageSize ?? 20 },
+      customerCtx(token)
+    ),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useUpdateCustomer() {
+  const { client } = useEmporix();
+  const ctx = useCustomerOnlyCtx();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (patch) => client.customers.update(patch, ctx),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: ["emporix", "customer", "me"] });
+    }
+  });
+}
+function useChangePassword() {
+  const { client } = useEmporix();
+  const ctx = useCustomerOnlyCtx();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.customers.changePassword(input, ctx)
+  });
+}
+var ADDRESSES_KEY = ["emporix", "customer", "addresses"];
+function useCustomerAddresses(options = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { activeCompany } = useActiveCompany();
+  const ctx = options.auth ?? (token ? emporixSdk.auth.customer(token) : null);
+  return reactQuery.useQuery({
+    queryKey: [
+      ...ADDRESSES_KEY,
+      { tenant: client.tenant, hasToken: token !== null, legalEntityId: activeCompany?.id ?? null }
+    ],
+    enabled: ctx !== null,
+    queryFn: () => client.customers.addresses.list(ctx)
+  });
+}
+function useAddressMutations() {
+  const { client } = useEmporix();
+  const ctx = useCustomerOnlyCtx();
+  const qc = reactQuery.useQueryClient();
+  const invalidate = () => {
+    void qc.invalidateQueries({ queryKey: ADDRESSES_KEY });
+  };
+  return {
+    add: reactQuery.useMutation({
+      mutationFn: (input) => client.customers.addresses.add(input, ctx),
+      onSuccess: invalidate
+    }),
+    update: reactQuery.useMutation({
+      mutationFn: ({ id, patch }) => client.customers.addresses.update(id, patch, ctx),
+      onSuccess: invalidate
+    }),
+    remove: reactQuery.useMutation({
+      mutationFn: ({ id }) => client.customers.addresses.remove(id, ctx),
+      onSuccess: invalidate
+    })
+  };
+}
+function usePasswordReset() {
+  const { client } = useEmporix();
+  const anonCtx = emporixSdk.auth.anonymous();
+  return {
+    request: reactQuery.useMutation({
+      mutationFn: (input) => client.customers.requestPasswordReset(input, anonCtx)
+    }),
+    confirm: reactQuery.useMutation({
+      mutationFn: (input) => client.customers.confirmPasswordReset(input, anonCtx)
+    })
+  };
+}
+var SITES_STALE_TIME = 10 * 6e4;
+function useSites(options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  return reactQuery.useQuery({
+    queryKey: emporixKey("sites", [], { tenant: client.tenant, authKind: ctx.kind }),
+    queryFn: () => client.sites.list(ctx),
+    staleTime: SITES_STALE_TIME
+  });
+}
+function useDefaultSite(options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  return reactQuery.useQuery({
+    queryKey: emporixKey("site-default", [], { tenant: client.tenant, authKind: ctx.kind }),
+    queryFn: () => client.sites.current(ctx),
+    staleTime: SITES_STALE_TIME
+  });
+}
+function useSiteContext() {
+  const ctx = react.useContext(EmporixSiteContext);
+  if (!ctx) {
+    throw new Error("useSiteContext must be used within an EmporixProvider");
+  }
+  return ctx;
+}
+function useMyCompanies() {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["mine"], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null,
+    queryFn: () => client.companies.listMine(emporixSdk.auth.customer(token))
+  });
+}
+function useCompany(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", [legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.companies.get(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCompanyContacts(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["contacts", legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.contacts.listForCompany(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCompanyLocations(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["locations", legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.locations.listForCompany(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCompanyGroups(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["groups", legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.customerGroups.listForCompany(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCustomerAuthResolver() {
+  const { storage } = useEmporix();
+  return () => {
+    const token = storage.getCustomerToken();
+    if (!token) throw new Error("Mutation requires a logged-in customer token");
+    return emporixSdk.auth.customer(token);
+  };
+}
+function useCreateCompany() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.companies.create(input, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["emporix", "companies", "mine"] })
+  });
+}
+function useUpdateCompany() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, patch }) => client.companies.update(id, patch, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["emporix", "companies"] })
+  });
+}
+function useDeleteCompany() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.companies.delete(id, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["emporix", "companies"] })
+  });
+}
+function useAssignContact() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.contacts.assign(input, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("contacts") })
+  });
+}
+function useUpdateContactAssignment() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, patch }) => client.contacts.update(id, patch, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("contacts") })
+  });
+}
+function useUnassignContact() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.contacts.unassign(id, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("contacts") })
+  });
+}
+function useCreateLocation() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.locations.create(input, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("locations") })
+  });
+}
+function useUpdateLocation() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, patch }) => client.locations.update(id, patch, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("locations") })
+  });
+}
+function useDeleteLocation() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.locations.delete(id, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("locations") })
+  });
+}
+function useCompanySwitcher() {
+  const ctx = useActiveCompany();
+  const switchFn = react.useCallback(
+    (legalEntityId) => ctx.setActiveCompany(legalEntityId),
+    [ctx]
+  );
+  const clearFn = react.useCallback(() => ctx.setActiveCompany(null), [ctx]);
+  return {
+    companies: ctx.myCompanies,
+    active: ctx.activeCompany,
+    status: ctx.status,
+    switch: switchFn,
+    clear: clearFn
+  };
+}
+function useMyOrders(options = {}) {
+  const { client, storage } = useEmporix();
+  const { activeCompany } = useActiveCompany();
+  const { siteCode } = useReadSite();
+  const token = storage.getCustomerToken();
+  const effectiveLE = options.legalEntityId === null ? void 0 : options.legalEntityId ?? activeCompany?.id;
+  return reactQuery.useQuery({
+    queryKey: emporixKey(
+      "orders",
+      ["mine", effectiveLE ?? null, options.status ?? null, options.pageNumber ?? 1, options.pageSize ?? null],
+      { tenant: client.tenant, authKind: token ? "customer" : "anonymous", siteCode }
+    ),
+    enabled: token !== null,
+    queryFn: () => client.orders.listMine(emporixSdk.auth.customer(token), {
+      ...options.pageNumber !== void 0 ? { pageNumber: options.pageNumber } : {},
+      ...options.pageSize !== void 0 ? { pageSize: options.pageSize } : {},
+      ...options.status !== void 0 ? { status: options.status } : {},
+      ...effectiveLE !== void 0 ? { legalEntityId: effectiveLE } : {},
+      ...siteCode ? { siteCode } : {},
+      ...options.saasToken !== void 0 ? { saasToken: options.saasToken } : {}
+    })
+  });
+}
+function useMyOrdersInfinite(options = {}) {
+  const { client, storage } = useEmporix();
+  const { activeCompany } = useActiveCompany();
+  const { siteCode } = useReadSite();
+  const token = storage.getCustomerToken();
+  const effectiveLE = options.legalEntityId === null ? void 0 : options.legalEntityId ?? activeCompany?.id;
+  return useEmporixInfinite({
+    queryKey: emporixKey(
+      "orders",
+      ["mine-infinite", effectiveLE ?? null, options.status ?? null, options.pageSize ?? null],
+      { tenant: client.tenant, authKind: token ? "customer" : "anonymous", siteCode }
+    ),
+    enabled: token !== null,
+    fetchPage: (pageNumber) => client.orders.listMine(emporixSdk.auth.customer(token), {
+      pageNumber,
+      ...options.pageSize !== void 0 ? { pageSize: options.pageSize } : {},
+      ...options.status !== void 0 ? { status: options.status } : {},
+      ...effectiveLE !== void 0 ? { legalEntityId: effectiveLE } : {},
+      ...siteCode ? { siteCode } : {},
+      ...options.saasToken !== void 0 ? { saasToken: options.saasToken } : {}
+    })
+  });
+}
+function useOrder(orderId, options = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("orders", [orderId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && orderId !== void 0,
+    queryFn: () => client.orders.get(
+      orderId,
+      emporixSdk.auth.customer(token),
+      options.saasToken ? { saasToken: options.saasToken } : {}
+    )
+  });
+}
+function useCancelOrder() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "orders", "cancel"],
+    mutationFn: async (input) => {
+      const token = storage.getCustomerToken();
+      if (!token) throw new Error("useCancelOrder: requires a logged-in customer");
+      const { orderId, saasToken } = typeof input === "string" ? { orderId: input, saasToken: void 0 } : input;
+      await client.orders.cancel(
+        orderId,
+        emporixSdk.auth.customer(token),
+        saasToken ? { saasToken } : {}
+      );
+    },
+    onSuccess: () => qc.invalidateQueries({
+      predicate: (q) => Array.isArray(q.queryKey) && q.queryKey[1] === "orders"
+    })
+  });
+}
+function useOrderTransition() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "orders", "transition"],
+    mutationFn: async ({ orderId, status, comment, saasToken }) => {
+      const token = storage.getCustomerToken();
+      if (!token) throw new Error("useOrderTransition: requires a logged-in customer");
+      await client.orders.transition(
+        orderId,
+        status,
+        emporixSdk.auth.customer(token),
+        {
+          ...comment !== void 0 ? { comment } : {},
+          ...saasToken !== void 0 ? { saasToken } : {}
+        }
+      );
+    },
+    onSuccess: () => qc.invalidateQueries({
+      predicate: (q) => Array.isArray(q.queryKey) && q.queryKey[1] === "orders"
+    })
+  });
+}
+function useReorder() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "orders", "reorder"],
+    mutationFn: async ({ orderId, saasToken }) => {
+      const token = storage.getCustomerToken();
+      if (!token) throw new Error("useReorder: requires a logged-in customer");
+      const ctx = emporixSdk.auth.customer(token);
+      const order = await qc.fetchQuery({
+        queryKey: emporixKey("orders", [orderId], { tenant: client.tenant, authKind: ctx.kind }),
+        queryFn: () => client.orders.get(orderId, ctx, saasToken ? { saasToken } : {})
+      });
+      const cartId = storage.getCartId();
+      if (!cartId) throw new Error("useReorder: no active cart id in storage");
+      if (order.items.length === 0) return { added: 0, errors: [] };
+      const batchBody = order.items.map((item) => ({
+        product: { id: item.productId },
+        quantity: item.quantity
+      }));
+      const res = await client.carts.addItemsBatch(cartId, batchBody, ctx);
+      let added = 0;
+      const errors = [];
+      for (const entry of res) {
+        if (entry.status >= 200 && entry.status < 300) {
+          added += 1;
+        } else {
+          errors.push(
+            new Error(
+              `addItemsBatch entry ${entry.index ?? "?"}: status=${entry.status}${entry.errorMessage ? " " + entry.errorMessage : ""}`
+            )
+          );
+        }
+      }
+      return { added, errors };
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ predicate: (q) => Array.isArray(q.queryKey) && q.queryKey[1] === "cart" });
+    }
+  });
+}
+function useSalesOrder(orderId, authCtx) {
+  const { client } = useEmporix();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("salesorders", [orderId ?? null], {
+      tenant: client.tenant,
+      authKind: authCtx?.kind ?? "anonymous"
+    }),
+    enabled: orderId !== void 0 && authCtx !== void 0,
+    queryFn: () => client.salesOrders.get(orderId, authCtx)
+  });
+}
+function useUpdateSalesOrder() {
+  const { client } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "salesorders", "update"],
+    mutationFn: async ({ orderId, patch, auth: auth22, recalculate }) => {
+      if (!auth22) throw new Error("useUpdateSalesOrder: requires an auth context");
+      return client.salesOrders.update(
+        orderId,
+        patch,
+        auth22,
+        recalculate !== void 0 ? { recalculate } : {}
+      );
+    },
+    onSuccess: (_data, vars) => {
+      qc.invalidateQueries({
+        predicate: (q) => Array.isArray(q.queryKey) && (q.queryKey[1] === "salesorders" || q.queryKey[1] === "orders" && q.queryKey[2] === vars.orderId)
+      });
+    }
+  });
+}
+
+exports.useActiveCart = useActiveCart;
+exports.useAddressMutations = useAddressMutations;
+exports.useAssignContact = useAssignContact;
+exports.useCancelOrder = useCancelOrder;
+exports.useCart = useCart;
+exports.useCartMutations = useCartMutations;
+exports.useCategories = useCategories;
+exports.useCategoriesInfinite = useCategoriesInfinite;
+exports.useCategory = useCategory;
+exports.useCategoryTree = useCategoryTree;
+exports.useChangePassword = useChangePassword;
+exports.useCheckout = useCheckout;
+exports.useCompany = useCompany;
+exports.useCompanyContacts = useCompanyContacts;
+exports.useCompanyGroups = useCompanyGroups;
+exports.useCompanyLocations = useCompanyLocations;
+exports.useCompanySwitcher = useCompanySwitcher;
+exports.useCreateCart = useCreateCart;
+exports.useCreateCompany = useCreateCompany;
+exports.useCreateLocation = useCreateLocation;
+exports.useCustomerAddresses = useCustomerAddresses;
+exports.useCustomerSession = useCustomerSession;
+exports.useDefaultSite = useDefaultSite;
+exports.useDeleteCompany = useDeleteCompany;
+exports.useDeleteLocation = useDeleteLocation;
+exports.useMatchPrices = useMatchPrices;
+exports.useMyCompanies = useMyCompanies;
+exports.useMyOrders = useMyOrders;
+exports.useMyOrdersInfinite = useMyOrdersInfinite;
+exports.useMySegmentCategories = useMySegmentCategories;
+exports.useMySegmentCategoriesInfinite = useMySegmentCategoriesInfinite;
+exports.useMySegmentCategoryTree = useMySegmentCategoryTree;
+exports.useMySegmentItems = useMySegmentItems;
+exports.useMySegmentProducts = useMySegmentProducts;
+exports.useMySegmentProductsInfinite = useMySegmentProductsInfinite;
+exports.useMySegments = useMySegments;
+exports.useOrder = useOrder;
+exports.useOrderTransition = useOrderTransition;
+exports.usePasswordReset = usePasswordReset;
+exports.usePaymentModes = usePaymentModes;
+exports.useProduct = useProduct;
+exports.useProductByCode = useProductByCode;
+exports.useProductMedia = useProductMedia;
+exports.useProductSearch = useProductSearch;
+exports.useProducts = useProducts;
+exports.useProductsInCategory = useProductsInCategory;
+exports.useProductsInCategoryInfinite = useProductsInCategoryInfinite;
+exports.useProductsInfinite = useProductsInfinite;
+exports.useReorder = useReorder;
+exports.useSalesOrder = useSalesOrder;
+exports.useSiteContext = useSiteContext;
+exports.useSites = useSites;
+exports.useUnassignContact = useUnassignContact;
+exports.useUpdateCompany = useUpdateCompany;
+exports.useUpdateContactAssignment = useUpdateContactAssignment;
+exports.useUpdateCustomer = useUpdateCustomer;
+exports.useUpdateLocation = useUpdateLocation;
+exports.useUpdateSalesOrder = useUpdateSalesOrder;
+//# sourceMappingURL=hooks.cjs.map
+//# sourceMappingURL=hooks.cjs.map