@zonos/elements 1.5.0 → 1.5.2

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

@@ -1,55 +1,32 @@
 import { isCountryCode } from "./isCountryCode";
+import { safeGetItem, safeRemoveItem, safeSetItem, } from "../safeStorage";
 const COUNTRY_OVERRIDE_KEY = 'zonos--country';
-const withBlockedStorage = (run) => {
-    try {
-        run();
-    }
-    catch (_a) {
-        // localStorage/sessionStorage can throw in blocked-storage contexts
-        // (Safari private mode, cross-origin iframes).
-    }
-};
-const readStoredCountry = (storage) => {
-    try {
-        const value = storage.getItem(COUNTRY_OVERRIDE_KEY);
-        if (!value || !isCountryCode(value)) {
-            return null;
-        }
-        return value;
-    }
-    catch (_a) {
+const readStoredCountry = (area) => {
+    const value = safeGetItem(area, COUNTRY_OVERRIDE_KEY);
+    if (!value || !isCountryCode(value)) {
         return null;
     }
+    return value;
 };
-const writeOverride = (storage, countryCode) => {
-    storage.setItem(COUNTRY_OVERRIDE_KEY, countryCode);
-};
-const withEachStorage = (run) => {
-    withBlockedStorage(() => run(window.localStorage));
-    withBlockedStorage(() => run(window.sessionStorage));
-};
-export const getCountryOverrideStorage = () => {
-    var _a;
-    return (_a = readStoredCountry(window.localStorage)) !== null && _a !== void 0 ? _a : readStoredCountry(window.sessionStorage);
-};
+export const getCountryOverrideStorage = () => { var _a; return (_a = readStoredCountry('local')) !== null && _a !== void 0 ? _a : readStoredCountry('session'); };
 export const migrateCountryOverrideStorage = (selectedCountryCode) => {
     if (!selectedCountryCode) {
         return;
     }
-    withBlockedStorage(() => {
-        const localCountry = readStoredCountry(window.localStorage);
-        // Only mirror the country Hello actually kept. A failed localStorage
-        // clear can leave a discarded country in local; never copy that to
-        // session for older Elements. Never copy session → local.
-        if (localCountry === selectedCountryCode) {
-            writeOverride(window.sessionStorage, localCountry);
-        }
-    });
+    const localCountry = readStoredCountry('local');
+    // Only mirror the country Hello actually kept. A failed localStorage
+    // clear can leave a discarded country in local; never copy that to
+    // session for older Elements. Never copy session → local.
+    if (localCountry === selectedCountryCode) {
+        safeSetItem('session', COUNTRY_OVERRIDE_KEY, localCountry);
+    }
 };
 export const setCountryOverrideStorage = (countryCode) => {
     // Dual-write so older Elements that only read sessionStorage see the pick.
-    withEachStorage(storage => writeOverride(storage, countryCode));
+    safeSetItem('local', COUNTRY_OVERRIDE_KEY, countryCode);
+    safeSetItem('session', COUNTRY_OVERRIDE_KEY, countryCode);
 };
 export const clearCountryOverrideStorage = () => {
-    withEachStorage(storage => storage.removeItem(COUNTRY_OVERRIDE_KEY));
+    safeRemoveItem('local', COUNTRY_OVERRIDE_KEY);
+    safeRemoveItem('session', COUNTRY_OVERRIDE_KEY);
 };

package/dist/collection/components/utils/logging/installConstructorCapture.js

@@ -0,0 +1,58 @@
+import { sendErrorLog } from "./sendErrorLog";
+import { thrownMessage } from "./thrownMessage";
+const constructorNotFound = /^Constructor for .+ was not found/;
+const constructorTag = /^Constructor for "?([^#"]+)#/;
+const recordConstructorFailure = (value) => {
+    var _a;
+    const message = thrownMessage(value, '');
+    if (!message || !constructorNotFound.test(message)) {
+        return;
+    }
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    const capture = window.__zonosConstructorCapture;
+    if (!capture) {
+        return;
+    }
+    const tagMatch = constructorTag.exec(message);
+    const tag = (_a = tagMatch === null || tagMatch === void 0 ? void 0 : tagMatch[1]) !== null && _a !== void 0 ? _a : '';
+    if (capture.reported.has(tag)) {
+        return;
+    }
+    capture.reported.add(tag);
+    void sendErrorLog({
+        endpoint: 'stencil://constructor',
+        errors: [message],
+        metadata: {
+            shape: 'constructor-not-found',
+            tag,
+        },
+    });
+};
+/**
+ * Copy a missing-constructor failure onto the existing error log.
+ * Stencil catches `Constructor for "tag#mode" was not found` and passes that
+ * Error to `console.error`. One report is sent per tag, then the original
+ * console.error still runs. This does not request the chunk again.
+ */
+export const installConstructorCapture = () => {
+    if (window.__zonosConstructorCapture) {
+        return;
+    }
+    const listener = (event) => {
+        recordConstructorFailure(event.reason);
+    };
+    window.__zonosConstructorCapture = {
+        listener,
+        reported: new Set(),
+    };
+    window.addEventListener('unhandledrejection', listener);
+    // eslint-disable-next-line no-console -- Stencil reports the missing constructor here
+    const originalError = console.error.bind(console);
+    // eslint-disable-next-line no-console -- record the Stencil diagnostic, then forward it
+    console.error = (...data) => {
+        recordConstructorFailure(data[0]);
+        originalError(...data);
+    };
+};

package/dist/collection/components/utils/logging/reportBlockedStorage.js

@@ -0,0 +1,34 @@
+import { sendErrorLog } from "./sendErrorLog";
+import { thrownMessage } from "./thrownMessage";
+const reportedIds = () => {
+    if (!window.__zonosReportedBlockedStorage) {
+        window.__zonosReportedBlockedStorage = new Set();
+    }
+    return window.__zonosReportedBlockedStorage;
+};
+/**
+ * Record a blocked storage read or write on the existing error log.
+ * A throw before `window.Zonos` exists is swallowed and does not use up
+ * the per-page dedupe slot, so the later startup read can still report it.
+ */
+export const reportBlockedStorage = (area, operation, key, error) => {
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    const dedupeId = `${area}\u0000${operation}\u0000${key}`;
+    const reported = reportedIds();
+    if (reported.has(dedupeId)) {
+        return;
+    }
+    reported.add(dedupeId);
+    void sendErrorLog({
+        endpoint: `storage://${area}/${key}`,
+        errors: [thrownMessage(error, 'SecurityError')],
+        metadata: {
+            area,
+            key,
+            operation,
+            shape: 'blocked-storage',
+        },
+    });
+};

package/dist/collection/components/utils/logging/sendErrorLog.js

@@ -5,6 +5,13 @@ import { log } from "./log";
  * @default 1 hour
  */
 const postReleaseReportingDuration = 1 * 3600 * 1000; // 1 hour
+const loggedHref = () => {
+    const url = new URL(window.location.href);
+    url.searchParams.delete('payment_intent');
+    url.searchParams.delete('payment_intent_client_secret');
+    url.searchParams.delete('redirect_status');
+    return url.toString();
+};
 export const sendErrorLog = async ({ endpoint, errors, metadata, shouldPostReleaseErrorReporting, }) => {
     log('sendErrorLog', 'warn', endpoint, metadata, errors);
     if (shouldPostReleaseErrorReporting) {
@@ -22,7 +29,7 @@ export const sendErrorLog = async ({ endpoint, errors, metadata, shouldPostRelea
     const errorObject = {
         endpoint,
         errors,
-        href: window.location.href,
+        href: loggedHref(),
         metadata: Object.assign({ appVersion: window.Zonos.version, domain: window.Zonos.domain, publicCredential: window.Zonos.zonosApiKey, userAgent: userAgentData && userAgentData.brands.length > 0
                 ? userAgentData
                 : window.navigator.userAgent }, metadata),

package/dist/collection/components/utils/logging/startZonosInit.js

@@ -0,0 +1,35 @@
+import { sendErrorLog } from "./sendErrorLog";
+import { thrownMessage } from "./thrownMessage";
+const reportInitRejection = (error) => {
+    // sendErrorLog prints only when zonosDebug is on. Keep the failure in the
+    // merchant console without leaving an unhandled rejection.
+    // eslint-disable-next-line no-console -- the page console is the support signal
+    console.error(error);
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    void sendErrorLog({
+        endpoint: 'zonos://init',
+        errors: [thrownMessage(error, 'Unknown init rejection')],
+        metadata: {
+            shape: 'init-rejection',
+        },
+    });
+};
+/**
+ * Run an init that the caller is not waiting on. The rejection is recorded
+ * and not rethrown, so startup does not become an unhandled rejection.
+ */
+export const startZonosInit = (start) => {
+    let pending;
+    try {
+        pending = start();
+    }
+    catch (error) {
+        reportInitRejection(error);
+        return;
+    }
+    void pending.catch((error) => {
+        reportInitRejection(error);
+    });
+};

package/dist/collection/components/utils/logging/thrownMessage.js

@@ -0,0 +1,16 @@
+export const thrownMessage = (error, fallback) => {
+    if (typeof error === 'string' && error) {
+        return error;
+    }
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        error.message) {
+        return error.message;
+    }
+    return fallback;
+};

package/dist/collection/components/utils/safeStorage.js

@@ -0,0 +1,39 @@
+import { reportBlockedStorage, } from "./logging/reportBlockedStorage";
+/**
+ * Touch `window.localStorage` / `window.sessionStorage` inside the try.
+ * Safari throws SecurityError on the getter itself when storage is blocked.
+ * A missing storage object is the same failure: calling `getItem` on it
+ * would report a TypeError instead of blocked storage.
+ */
+const storageFor = (area) => {
+    const storage = area === 'local' ? window.localStorage : window.sessionStorage;
+    if (!storage) {
+        throw new DOMException('', 'SecurityError');
+    }
+    return storage;
+};
+export const safeGetItem = (area, key) => {
+    try {
+        return storageFor(area).getItem(key);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'getItem', key, error);
+        return null;
+    }
+};
+export const safeRemoveItem = (area, key) => {
+    try {
+        storageFor(area).removeItem(key);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'removeItem', key, error);
+    }
+};
+export const safeSetItem = (area, key, value) => {
+    try {
+        storageFor(area).setItem(key, value);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'setItem', key, error);
+    }
+};

package/dist/collection/components/utils/taxId/taxIdRules.js

@@ -0,0 +1,44 @@
+import { checkoutTaxIdTypeValues, isCountryRequireTaxId, peruTaxIdDigitLength, shipToTaxIdLabels, taxIdTypeOptions, } from "../../../types/checkout/TaxId";
+export const stripTaxIdSeparators = (taxId) => taxId.replace(/[\s-]/g, '');
+export const rfcRegex = /^[A-ZÑ]{3,4}[0-9]{6}[A-Z0-9]{3}$/;
+export const curpRegex = /^[A-Z]{4}[0-9]{6}[HMX][A-Z]{5}[A-Z0-9][0-9]$/;
+export const isMexicoTaxIdType = (taxIdType) => taxIdTypeOptions.MX.some(option => option.value === taxIdType);
+export const isPeruTaxIdType = (taxIdType) => taxIdTypeOptions.PE.some(option => option.value === taxIdType);
+export const isCheckoutTaxIdTypeValue = (taxIdType) => checkoutTaxIdTypeValues.some(value => value === taxIdType);
+/** 8 digits are a DNI, 9 a carné, 11 an RUC. Anything else is not a Peru tax id. */
+export const peruTaxIdTypeFromValue = (taxId) => {
+    const digits = stripTaxIdSeparators(taxId);
+    if (!/^\d+$/.test(digits)) {
+        return null;
+    }
+    if (digits.length === peruTaxIdDigitLength.DNI) {
+        return 'DNI';
+    }
+    if (digits.length === peruTaxIdDigitLength.CE) {
+        return 'CE';
+    }
+    if (digits.length === peruTaxIdDigitLength.RUC) {
+        return 'RUC';
+    }
+    return null;
+};
+export const isPeruTaxIdActive = ({ countryCode, shouldRequirePeruTaxId, }) => shouldRequirePeruTaxId && countryCode === 'PE';
+/**
+ * Peru stays off `countryRequireTaxId`. The API flag decides which stores see it.
+ * Mexico and Peru pick the kind from a dropdown instead of a regex.
+ */
+export const taxIdTypeOptionsForCheckout = ({ countryCode, shouldRequirePeruTaxId, }) => {
+    if (isPeruTaxIdActive({ countryCode, shouldRequirePeruTaxId })) {
+        return taxIdTypeOptions.PE;
+    }
+    if (countryCode === 'MX') {
+        return taxIdTypeOptions.MX;
+    }
+    return null;
+};
+export const taxIdLabelForCheckout = (countryCode) => {
+    if (isCountryRequireTaxId(countryCode)) {
+        return shipToTaxIdLabels[countryCode];
+    }
+    return null;
+};

package/dist/collection/components/utils/taxIdValidationResult.js

@@ -1,5 +1,7 @@
-import { shouldRenderTaxIdInput } from "./checkout/shouldRenderTaxIdInput";
+import { resolveTaxIdSelection } from "./checkout/resolveTaxIdSelection";
+import { curpRegex, isPeruTaxIdActive, isPeruTaxIdType, peruTaxIdTypeFromValue, rfcRegex, stripTaxIdSeparators, } from "./taxId/taxIdRules";
 import { euCountryCodes } from "../../types/index";
+import { peruTaxIdFormatError, } from "../../types/checkout/TaxId";
 const isTaxIdRequired = (shippingCountry) => {
     const requireTaxIdCountry = [
         'MX',
@@ -8,86 +10,83 @@ const isTaxIdRequired = (shippingCountry) => {
     ];
     return requireTaxIdCountry.includes(shippingCountry);
 };
-export const taxIdValidationResult = ({ companyName, shippingCountry, taxId, }) => {
-    // Check to see if we are required to collect tax id for the shipping country or not
-    const isTaxIdInputRendered = shouldRenderTaxIdInput({
+const invalid = (error, field) => ({
+    error,
+    field,
+    valid: false,
+});
+const valid = () => ({
+    error: null,
+    field: null,
+    valid: true,
+});
+export const taxIdValidationResult = ({ companyName, shippingCountry, shouldRequirePeruTaxId, taxId, taxIdType, }) => {
+    const { rendered, selectedType, typeOptions } = resolveTaxIdSelection({
         companyName,
         countryCode: shippingCountry,
+        shouldRequirePeruTaxId,
+        taxIdType,
     });
     // If the tax id input is not even rendered, no need to validate anything and allow to proceed. Validate when tax id input is not even rendered would prevent the user from checking out
-    if (!isTaxIdInputRendered) {
-        return {
-            error: null,
-            valid: true,
-        };
+    if (!rendered) {
+        return valid();
+    }
+    // The number field is hidden until a type is chosen.
+    if (typeOptions && !selectedType) {
+        return invalid('Tax id type is required', 'type');
+    }
+    // Spaces and hyphens count as blank only. The original text is left unchanged.
+    if (isPeruTaxIdActive({
+        countryCode: shippingCountry,
+        shouldRequirePeruTaxId,
+    }) &&
+        selectedType &&
+        isPeruTaxIdType(selectedType.value)) {
+        if (!stripTaxIdSeparators(taxId)) {
+            return invalid('Tax id is required', 'value');
+        }
+        if (peruTaxIdTypeFromValue(taxId) !== selectedType.value) {
+            return invalid(peruTaxIdFormatError[selectedType.value], 'value');
+        }
+        return valid();
     }
     // Cache the result of isTaxIdRequired for reuse
     const taxIdRequired = isTaxIdRequired(shippingCountry);
     if (!taxIdRequired) {
         // If the shipping country does not require a tax id, the validation immediately returns valid
-        return {
-            error: null,
-            valid: true,
-        };
+        return valid();
     }
     // For all EU countries, tax id is not required if company name is not filled (not business address)
     if (euCountryCodes.includes(shippingCountry)) {
         if (!companyName.trim()) {
-            return {
-                error: null,
-                valid: true,
-            };
+            return valid();
         }
         if (!taxId) {
-            return {
-                error: 'Tax id is required',
-                valid: false,
-            };
+            return invalid('Tax id is required', 'value');
         }
-        return {
-            error: null,
-            valid: true,
-        };
+        return valid();
     }
     if (!taxId) {
-        return {
-            error: 'Tax id is required',
-            valid: false,
-        };
+        return invalid('Tax id is required', 'value');
     }
     if (shippingCountry === 'AR') {
-        const isValid = /^[0-9]{2}-?[0-9]{8}-?[0-9]$/.test(taxId);
-        if (!isValid) {
-            return {
-                error: 'Invalid CUIT/CUIL format. Must contain 11 digits, with or without dashes (XX-XXXXXXXX-X).',
-                valid: false,
-            };
+        const isValidAr = /^[0-9]{2}-?[0-9]{8}-?[0-9]$/.test(taxId);
+        if (!isValidAr) {
+            return invalid('Invalid CUIT/CUIL format. Must contain 11 digits, with or without dashes (XX-XXXXXXXX-X).', 'value');
         }
-        return {
-            error: null,
-            valid: true,
-        };
+        return valid();
     }
-    // validate tax id for mexico;
-    if (shippingCountry === 'MX') {
-        // RFC: 3-4 letters + 6 digit date + 3 character homoclave (12-13 total)
-        const isValidRfc = /^[A-ZÑ]{3,4}[0-9]{6}[A-Z0-9]{3}$/.test(taxId);
-        // CURP: 4 letters + 6 digit date + gender (H/M/X) + 5 letters + alphanumeric + digit (18 total)
-        const isValidCurp = /^[A-Z]{4}[0-9]{6}[HMX][A-Z]{5}[A-Z0-9][0-9]$/.test(taxId);
-        if (!isValidRfc && !isValidCurp) {
-            return {
-                error: 'Invalid RFC or CURP format. Must be a 12–13 character RFC or an 18 character CURP, uppercase letters and numbers only.',
-                valid: false,
-            };
+    // validate tax id for mexico against the type the shopper selected
+    if (shippingCountry === 'MX' && selectedType) {
+        const isRfc = selectedType.value === 'RFC';
+        const isValidMx = isRfc ? rfcRegex.test(taxId) : curpRegex.test(taxId);
+        if (!isValidMx) {
+            return invalid(isRfc
+                ? 'Invalid RFC format. Must be 12–13 uppercase letters and numbers.'
+                : 'Invalid CURP format. Must be 18 uppercase letters and numbers.', 'value');
         }
-        return {
-            error: null,
-            valid: true,
-        };
+        return valid();
     }
     //  Other countries doesn't need to validate tax id in the right format
-    return {
-        error: null,
-        valid: true,
-    };
+    return valid();
 };

package/dist/collection/index.js

@@ -1,2 +1,3 @@
+export { curpRegex, isMexicoTaxIdType, isPeruTaxIdType, peruTaxIdTypeFromValue, stripTaxIdSeparators, } from './components/utils/taxId/taxIdRules';
 export { Zonos } from './scripts';
 export * from './types';

package/dist/collection/scripts/_getZonosQaUrl.js

@@ -1,4 +1,5 @@
 import { log } from "../components/utils/logging/log";
+import { safeRemoveItem } from "../components/utils/safeStorage";
 import { extractZonosQaUrl, extractZonosQaUrlApi, } from "./_extractZonosQaUrl";
 /**
  * Get the Zonos QA URL and return it. Will remove `zonosQaUrl` from the url query if it doesn't exists.
@@ -49,8 +50,8 @@ export const getZonosQaUrl = () => {
     void fetch(fullUrl)
         .then(() => {
         // cleanup checkout session to avoid using the prod session in preview domain
-        window.sessionStorage.removeItem('zonos--checkout-session-id');
-        window.sessionStorage.removeItem('zonos--client-secret');
+        safeRemoveItem('session', 'zonos--checkout-session-id');
+        safeRemoveItem('session', 'zonos--client-secret');
     })
         .catch(() => {
         alert(`[ZONOS-WARNING] '${fullUrl}' IS NO LONGER AVAILABLE. REMOVING zonosQaUrl PARAM AND RELOADING THE PAGE`);

package/dist/collection/scripts/_zonosBase.js

@@ -1,8 +1,11 @@
 var _a;
 import { createCustomEvent } from "../components/utils/createCustomEvent";
 import { IframeService } from "../components/utils/iframe/IframeHelpers";
+import { installConstructorCapture } from "../components/utils/logging/installConstructorCapture";
 import { log } from "../components/utils/logging/log";
 import { logError } from "../components/utils/logging/logError";
+import { startZonosInit } from "../components/utils/logging/startZonosInit";
+import { safeGetItem } from "../components/utils/safeStorage";
 import { checkIfLoadVersionDomain } from "./_checkIfLoadVersionDomain";
 import { getNextFallbackUrl, MAIN_LOAD_CDN_TYPE, } from "./_getNextFallbackUrl";
 import { getWithTestPublicCredential } from "./_getWithTestPublicCredential";
@@ -85,6 +88,7 @@ Zonos.zonosController = null;
 Zonos.loadTimeApiInfoList = [];
 Zonos.logIntervalId = null;
 Zonos.init = async (params) => {
+    installConstructorCapture();
     const { appearance, checkoutSettings, currencyConverter, helloSettings, onCountryChange, overrideCurrencyFormat, storeId, zonosApiKey, } = params;
     _a.cartId = getCartIdFromQueryParam();
     // Expose the checkout cart callbacks on the global so Stripe loading can be
@@ -120,7 +124,7 @@ Zonos.init = async (params) => {
                 window.Zonos.isLegacyCheckout = _a.isLegacyCheckout;
                 window.Zonos.zonosMode = _a.zonosMode;
                 // call init again after the script is loaded
-                void window.Zonos.init(params);
+                startZonosInit(() => window.Zonos.init(params));
             });
             script.addEventListener('error', () => {
                 alert(`[ZONOS - loadZonos] Failed to load "loadZonos.js" from zonosQaUrl: ${zonosQaUrl}`);
@@ -156,7 +160,7 @@ Zonos.init = async (params) => {
         }
     }
     // Check if the stripe client secret is available in the url or session storage, inject hidden button to trigger checkout right away to check status of client secret
-    const clientSecretUrlParam = new URL(window.location.href).searchParams.get('payment_intent_client_secret') || sessionStorage.getItem('zonos--client-secret');
+    const clientSecretUrlParam = new URL(window.location.href).searchParams.get('payment_intent_client_secret') || safeGetItem('session', 'zonos--client-secret');
     const shouldAttemptImmediatelyOpenCheckout = (_a.cartId && _a.cartData) || !!clientSecretUrlParam;
     // inject hidden button to body to trigger checkout right away if we have cartData or stripe client secret
     if (shouldAttemptImmediatelyOpenCheckout) {

package/dist/collection/types/checkout/TaxId.js

@@ -86,3 +86,34 @@ export const shipToTaxIdLabels = {
     SI: { friendlyName: 'EORI number', placeholder: 'DE123456789' },
     SK: { friendlyName: 'EORI number', placeholder: 'DE123456789' },
 };
+export const isCountryRequireTaxId = (countryCode) => {
+    return countryRequireTaxId.some(code => code === countryCode);
+};
+export const taxIdTypeOptions = {
+    MX: [
+        { label: 'RFC', placeholder: 'XAXX010101000', value: 'RFC' },
+        { label: 'CURP', placeholder: 'AAAA800101HDFRRR09', value: 'CURP' },
+    ],
+    PE: [
+        { label: 'DNI', placeholder: '12345678', value: 'DNI' },
+        { label: 'RUC', placeholder: '20123456789', value: 'RUC' },
+        {
+            label: 'Carné de extranjería',
+            placeholder: '001234567',
+            value: 'CE',
+        },
+    ],
+};
+const checkoutTaxIdTypeValueList = ['CE', 'CURP', 'DNI', 'RFC', 'RUC'];
+/** Every document kind checkout can send. Older clients omit the field. */
+export const checkoutTaxIdTypeValues = checkoutTaxIdTypeValueList;
+export const peruTaxIdDigitLength = {
+    CE: 9,
+    DNI: 8,
+    RUC: 11,
+};
+export const peruTaxIdFormatError = {
+    CE: 'Carné de extranjería must be 9 digits.',
+    DNI: 'DNI must be 8 digits.',
+    RUC: 'RUC must be 11 digits.',
+};

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

@@ -665,14 +665,6 @@ export function getSdk(client, withWrapper = defaultWrapper) {
                 variables,
             }), 'insertOrderImportLock', 'mutation', variables);
         },
-        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, signal) {
             return withWrapper(wrappedRequestHeaders => client.request({
                 document: '',
@@ -713,14 +705,6 @@ export function getSdk(client, withWrapper = defaultWrapper) {
                 variables,
             }), 'storeVersionSetting', 'query', variables);
         },
-        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, signal) {
             return withWrapper(wrappedRequestHeaders => client.request({
                 document: '',