@zonos/elements 1.3.288 → 1.3.290

package/dist/collection/components/utils/hello/resolveHelloFloatPlacement.js

@@ -0,0 +1,98 @@
+const isValidHelloPlacement = (value) => {
+    if (value == null || typeof value !== 'object') {
+        return false;
+    }
+    const { anchor, horizontalOffset, verticalOffset } = value;
+    return (typeof anchor === 'string' &&
+        anchor.length > 0 &&
+        typeof horizontalOffset === 'number' &&
+        Number.isFinite(horizontalOffset) &&
+        typeof verticalOffset === 'number' &&
+        Number.isFinite(verticalOffset));
+};
+const includesLeft = (location) => Boolean(location === null || location === void 0 ? void 0 : location.includes('LEFT'));
+const includesTop = (location) => Boolean(location === null || location === void 0 ? void 0 : location.includes('TOP'));
+const buildResolved = ({ anchor, animateFromLeftOverride, horizontalOffset, isMobileWindow, isOnLeft, shouldFloat, verticalOffset, }) => ({
+    anchor,
+    horizontalOffset,
+    isMobileWindow,
+    isOnLeft: isOnLeft !== null && isOnLeft !== void 0 ? isOnLeft : (Boolean(animateFromLeftOverride) || includesLeft(anchor)),
+    isOnTop: includesTop(anchor),
+    shouldFloat,
+    verticalOffset,
+});
+/**
+ * Resolve active Hello float placement per viewport.
+ * Precedence: component enum prop → settings HelloPlacement → settings location enum.
+ *
+ * When the winning source is a component enum prop or settings `HelloPlacement`,
+ * `shouldFloat` is always true — including when `anchorElementSelector` is set.
+ * That matches existing prop-forced float behavior and FR-006 / data-model rules
+ * (placement implies floating; enum fallback still respects the anchor selector).
+ */
+export const resolveHelloFloatPlacement = (params) => {
+    const { anchorElementSelector, animateFromLeftOverride, componentDesktopLocation, componentMobileLocation, desktopLocation, isMobileWindow, mobileLocation, settingsDesktopPlacement, settingsMobilePlacement, shouldAnimateLeftDesktop, } = params;
+    if (isMobileWindow) {
+        if (componentMobileLocation) {
+            return buildResolved({
+                anchor: componentMobileLocation,
+                animateFromLeftOverride,
+                horizontalOffset: null,
+                isMobileWindow: true,
+                shouldFloat: true,
+                verticalOffset: null,
+            });
+        }
+        if (isValidHelloPlacement(settingsMobilePlacement)) {
+            return buildResolved({
+                anchor: settingsMobilePlacement.anchor,
+                animateFromLeftOverride,
+                horizontalOffset: settingsMobilePlacement.horizontalOffset,
+                isMobileWindow: true,
+                shouldFloat: true,
+                verticalOffset: settingsMobilePlacement.verticalOffset,
+            });
+        }
+        return buildResolved({
+            anchor: mobileLocation,
+            animateFromLeftOverride,
+            horizontalOffset: null,
+            isMobileWindow: true,
+            shouldFloat: Boolean(mobileLocation),
+            verticalOffset: null,
+        });
+    }
+    if (componentDesktopLocation) {
+        return buildResolved({
+            anchor: componentDesktopLocation,
+            animateFromLeftOverride,
+            horizontalOffset: null,
+            isMobileWindow: false,
+            shouldFloat: true,
+            verticalOffset: null,
+        });
+    }
+    if (isValidHelloPlacement(settingsDesktopPlacement)) {
+        return buildResolved({
+            anchor: settingsDesktopPlacement.anchor,
+            animateFromLeftOverride,
+            horizontalOffset: settingsDesktopPlacement.horizontalOffset,
+            isMobileWindow: false,
+            shouldFloat: true,
+            verticalOffset: settingsDesktopPlacement.verticalOffset,
+        });
+    }
+    const shouldFloat = !anchorElementSelector && Boolean(desktopLocation);
+    const isOnLeft = Boolean(animateFromLeftOverride) ||
+        (shouldFloat && desktopLocation
+            ? includesLeft(desktopLocation)
+            : Boolean(shouldAnimateLeftDesktop === null || shouldAnimateLeftDesktop === void 0 ? void 0 : shouldAnimateLeftDesktop()));
+    return buildResolved({
+        anchor: desktopLocation,
+        horizontalOffset: null,
+        isMobileWindow: false,
+        isOnLeft,
+        shouldFloat,
+        verticalOffset: null,
+    });
+};

package/dist/collection/components/utils/hello/shouldShowHelloWidget.js

@@ -1,35 +1,25 @@
 import { localizationStore } from "../../store/hello/localization";
 import { zonosStore } from "../../store/zonosStore";
+import { isCountryInShippingZone } from "./isCountryInShippingZone";
 import { log } from "../logging/log";
 /**
- * Whether the Hello widget should be shown for the current shopper. This is the
- * single source of truth for Hello's visibility decision — the `zonos-hello`
- * component renders by it, and other features (e.g. BigCommerce cart shipping
- * cleanup) gate on it so their behavior stays in lockstep with what the shopper
- * actually sees.
- *
- * Resolves the configured `widgetVisibility` behavior (with the deprecated
- * `showForCountries` override) against the selected country and shipping-zone
- * state, then applies the include/exclude country overrides.
- *
- * @param showLog - emit a debug log when the shopper is not in a shipping zone.
- * Defaults to `true`; pass `false` from non-rendering callers to avoid log
- * noise.
+ * Visibility rules for Hello, ignoring whether localization has finished
+ * loading. Used during init reconcile before `localizationLoaded` is set.
+ * Pass `countryCode` to evaluate a remembered country instead of the
+ * currently selected one.
  */
-export const shouldShowHelloWidget = (showLog = true) => {
+export const getHelloWidgetVisibility = (showLog = true, countryCode = localizationStore.selectedCountryCode) => {
     var _a, _b;
-    if (!localizationStore.localizationLoaded) {
-        return false;
-    }
     const { countryDisplayRules, showForCountries } = zonosStore.helloSettings;
     const visibilityRules = countryDisplayRules === null || countryDisplayRules === void 0 ? void 0 : countryDisplayRules.widgetVisibility;
-    const selectedCountry = localizationStore.selectedCountryCode;
+    const selectedCountry = countryCode;
+    const isShippableCountry = isCountryInShippingZone(countryCode);
     // Resolve behavior: deprecated showForCountries overrides widgetVisibility.behavior
     // If showForCountries is an array of country codes, treat as legacy explicit list
     const behavior = Array.isArray(showForCountries)
         ? showForCountries
         : (showForCountries !== null && showForCountries !== void 0 ? showForCountries : visibilityRules === null || visibilityRules === void 0 ? void 0 : visibilityRules.behavior);
-    if (showLog && !localizationStore.isShippableCountry) {
+    if (showLog && !isShippableCountry) {
         log(`Hello: not shippable country - Show for countries: ${behavior}`);
     }
     // Legacy: explicit list of country codes from deprecated showForCountries
@@ -43,7 +33,7 @@ export const shouldShowHelloWidget = (showLog = true) => {
     }
     else {
         // Default: ONLY_SHIPPABLE
-        isVisible = localizationStore.isShippableCountry;
+        isVisible = isShippableCountry;
     }
     // Apply includedCountries — force show the widget for these countries
     if (!isVisible &&
@@ -59,3 +49,20 @@ export const shouldShowHelloWidget = (showLog = true) => {
     }
     return isVisible;
 };
+/**
+ * Whether the Hello widget should be shown for the current shopper. This is the
+ * single source of truth for Hello's visibility decision — the `zonos-hello`
+ * component renders by it, and other features (e.g. BigCommerce cart shipping
+ * cleanup) gate on it so their behavior stays in lockstep with what the shopper
+ * actually sees.
+ *
+ * @param showLog - emit a debug log when the shopper is not in a shipping zone.
+ * Defaults to `true`; pass `false` from non-rendering callers to avoid log
+ * noise.
+ */
+export const shouldShowHelloWidget = (showLog = true) => {
+    if (!localizationStore.localizationLoaded) {
+        return false;
+    }
+    return getHelloWidgetVisibility(showLog);
+};

package/dist/collection/environment.js

@@ -78,7 +78,6 @@ export const env = createEnv({
     },
     // eslint-disable-next-line sort-keys/sort-keys-fix
     client: envClient,
-    // eslint-disable-next-line sort-keys/sort-keys-fix
     runtimeEnvStrict: {
         NEXT_PUBLIC_FLAG_URL: process.env.NEXT_PUBLIC_FLAG_URL,
         NEXT_PUBLIC_RELEASE_DATE: new Date().getTime().toString(),

package/dist/collection/scripts/_stripe.js

@@ -77,7 +77,6 @@ export const zonosStripeLoadScript = (params) => {
     });
     return stripePromise;
 };
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const registerWrapper = (stripe, startTime) => {
     if (!stripe || !stripe._registerWrapper) {
         return;
@@ -92,7 +91,6 @@ export const initStripe = (maybeStripe, args, startTime) => {
     registerWrapper(stripe, startTime);
     return stripe;
 };
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export const validateLoadParams = (params) => {
     const errorMessage = `invalid load parameters; expected object of shape
 

package/dist/collection/scripts/_zonosBase.js

@@ -90,7 +90,7 @@ Zonos.init = async (params) => {
     // Expose the checkout cart callbacks on the global so Stripe loading can be
     // gated on whether at least one of them is configured.
     _a.createCartId = checkoutSettings === null || checkoutSettings === void 0 ? void 0 : checkoutSettings.createCartId;
-    // eslint-disable-next-line deprecation/deprecation -- intentionally mirror the (deprecated) callback so Stripe loading can be gated on it
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- intentionally mirror the (deprecated) callback so Stripe loading can be gated on it
     _a.buildCartDetail = checkoutSettings === null || checkoutSettings === void 0 ? void 0 : checkoutSettings.buildCartDetail;
     if (_a.doneInit) {
         // do nothing if zonos is already initialized

package/dist/collection/types/generated/graphql.frontend.types.js

@@ -478,101 +478,256 @@ export const promptBulkJobStatusEnum = {
     InProgress: 'in_progress',
     Queued: 'queued',
 };
-const defaultWrapper = (action, _operationName, _operationType) => action();
+const defaultWrapper = (action, _operationName, _operationType, _variables) => action();
 export function getSdk(client, withWrapper = defaultWrapper) {
     return {
-        allSettings(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'allSettings', 'query');
+        allSettings(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'allSettings', 'query', variables);
         },
-        analyticConversionEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'analyticConversionEvent', 'query');
+        analyticConversionEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'analyticConversionEvent', 'query', variables);
         },
-        cleanupTestErrors(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'cleanupTestErrors', 'mutation');
+        cleanupTestErrors(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'cleanupTestErrors', 'mutation', variables);
         },
-        cleanupTestZonosElementSetting(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'cleanupTestZonosElementSetting', 'mutation');
+        cleanupTestZonosElementSetting(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'cleanupTestZonosElementSetting', 'mutation', variables);
         },
-        createBulkLoadEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'createBulkLoadEvent', 'mutation');
+        createBulkLoadEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'createBulkLoadEvent', 'mutation', variables);
         },
-        createBulkScriptLoadEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'createBulkScriptLoadEvent', 'mutation');
+        createBulkScriptLoadEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'createBulkScriptLoadEvent', 'mutation', variables);
         },
-        createErrorEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'createErrorEvent', 'mutation');
+        createErrorEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'createErrorEvent', 'mutation', variables);
         },
-        createScriptLoadEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'createScriptLoadEvent', 'mutation');
+        createScriptLoadEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'createScriptLoadEvent', 'mutation', variables);
         },
-        createStoreVersionSetting(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'createStoreVersionSetting', 'mutation');
+        createStoreVersionSetting(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'createStoreVersionSetting', 'mutation', variables);
         },
-        deleteAllStoreReserveOrders(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'deleteAllStoreReserveOrders', 'mutation');
+        deleteAllStoreReserveOrders(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'deleteAllStoreReserveOrders', 'mutation', variables);
         },
-        deleteBigCommerceSettings(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'deleteBigCommerceSettings', 'mutation');
+        deleteBigCommerceSettings(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'deleteBigCommerceSettings', 'mutation', variables);
         },
-        deleteOrderImportLock(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'deleteOrderImportLock', 'mutation');
+        deleteOrderImportLock(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'deleteOrderImportLock', 'mutation', variables);
         },
-        deleteReserveOrders(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'deleteReserveOrders', 'mutation');
+        deleteReserveOrders(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'deleteReserveOrders', 'mutation', variables);
         },
-        failToGetQuoteErrors(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'failToGetQuoteErrors', 'query');
+        failToGetQuoteErrors(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'failToGetQuoteErrors', 'query', variables);
         },
-        getAudienceByAspectKey(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'getAudienceByAspectKey', 'query');
+        getAudienceByAspectKey(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'getAudienceByAspectKey', 'query', variables);
         },
-        getBigCommerceSettings(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'getBigCommerceSettings', 'query');
+        getBigCommerceSettings(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'getBigCommerceSettings', 'query', variables);
         },
-        getConversionEventBySessionIdAndOrgId(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'getConversionEventBySessionIdAndOrgId', 'query');
+        getConversionEventBySessionIdAndOrgId(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'getConversionEventBySessionIdAndOrgId', 'query', variables);
         },
-        getReserveOrder(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'getReserveOrder', 'query');
+        getReserveOrder(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'getReserveOrder', 'query', variables);
         },
-        getSettingsReserveOrders(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'getSettingsReserveOrders', 'query');
+        getSettingsReserveOrders(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'getSettingsReserveOrders', 'query', variables);
         },
-        hasPreviousErrors(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'hasPreviousErrors', 'query');
+        hasPreviousErrors(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'hasPreviousErrors', 'query', variables);
         },
-        insertBigCommerceSettingsEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'insertBigCommerceSettingsEvent', 'mutation');
+        insertBigCommerceSettingsEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'insertBigCommerceSettingsEvent', 'mutation', variables);
         },
-        insertConversionEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'insertConversionEvent', 'mutation');
+        insertConversionEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'insertConversionEvent', 'mutation', variables);
         },
-        insertOrderImportLock(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'insertOrderImportLock', 'mutation');
+        insertOrderImportLock(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'insertOrderImportLock', 'mutation', variables);
         },
-        insertReserveOrder(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'insertReserveOrder', 'mutation');
+        insertReserveOrder(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'insertReserveOrder', 'mutation', variables);
         },
-        insertReserveOrderEvent(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'insertReserveOrderEvent', 'mutation');
+        insertReserveOrderEvent(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'insertReserveOrderEvent', 'mutation', variables);
         },
-        localeCountryMessages(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'localeCountryMessages', 'query');
+        localeCountryMessages(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'localeCountryMessages', 'query', variables);
         },
-        metricAllApiPaths(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'metricAllApiPaths', 'query');
+        metricAllApiPaths(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'metricAllApiPaths', 'query', variables);
         },
-        metricApiPathSpeed(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'metricApiPathSpeed', 'query');
+        metricApiPathSpeed(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'metricApiPathSpeed', 'query', variables);
         },
-        storeVersionSetting(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'storeVersionSetting', 'query');
+        storeVersionSetting(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'storeVersionSetting', 'query', variables);
         },
-        updateReserveOrder(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'updateReserveOrder', 'mutation');
+        updateReserveOrder(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'updateReserveOrder', 'mutation', variables);
         },
-        upsertBigCommerceSettings(variables, requestHeaders) {
-            return withWrapper(wrappedRequestHeaders => client.request('', variables, Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders)), 'upsertBigCommerceSettings', 'mutation');
+        upsertBigCommerceSettings(variables, requestHeaders, signal) {
+            return withWrapper(wrappedRequestHeaders => client.request({
+                document: '',
+                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
+                signal,
+                variables,
+            }), 'upsertBigCommerceSettings', 'mutation', variables);
         },
     };
 }