@marteye/studiojs 1.1.48 → 1.1.49-beta.0

package/dist/index.js

@@ -592,37 +592,73 @@ function buildMembersQueryParams(options) {
     }
     return Object.keys(queryParams).length > 0 ? queryParams : undefined;
 }
+function getRole(filters) {
+    var _a;
+    return (_a = filters.role) !== null && _a !== void 0 ? _a : "both";
+}
+function getSourceCustomerType(filters) {
+    var _a;
+    if (filters.sourceCustomerType) {
+        return filters.sourceCustomerType;
+    }
+    return filters.sourceSaleId || ((_a = filters.sourceCustomerIds) === null || _a === void 0 ? void 0 : _a.length)
+        ? "seller"
+        : null;
+}
+function getSourceCustomerIdField(sourceCustomerType) {
+    return sourceCustomerType === "buyer"
+        ? "buyerCustomerId"
+        : "sellerCustomerId";
+}
 function buildPreviewQueryParams(filters) {
     var _a;
     let params = {};
     let filter = buildFilterExpression(filters);
     let excludeFilters = buildExcludeFilters(filters);
+    let sourceCustomerType = getSourceCustomerType(filters);
     if (filter) {
         params.filter = filter;
     }
     if (excludeFilters.length > 0) {
         params.excludeFilters = JSON.stringify(excludeFilters);
     }
-    params.role = (_a = filters.role) !== null && _a !== void 0 ? _a : "both";
+    params.role = getRole(filters);
     if (filters.geoBounds) {
         params.bounds = JSON.stringify(filters.geoBounds);
     }
     if (filters.secondaryFilter) {
+        let secondarySourceCustomerType = getSourceCustomerType(filters.secondaryFilter);
         params.secondaryFilter = JSON.stringify({
-            role: filters.secondaryFilter.role,
+            role: getRole(filters.secondaryFilter),
             filter: buildFilterExpression(filters.secondaryFilter),
+            ...(secondarySourceCustomerType
+                ? { sourceCustomerType: secondarySourceCustomerType }
+                : {}),
+            ...(((_a = filters.secondaryFilter.sourceCustomerIds) === null || _a === void 0 ? void 0 : _a.length)
+                ? { sourceCustomerIds: filters.secondaryFilter.sourceCustomerIds }
+                : {}),
             ...(filters.secondaryFilter.geoBounds
                 ? { bounds: filters.secondaryFilter.geoBounds }
                 : {}),
         });
     }
+    if (sourceCustomerType) {
+        params.sourceCustomerType = sourceCustomerType;
+    }
+    if (filters.sourceSaleId) {
+        params.sourceSaleId = filters.sourceSaleId;
+    }
+    if (filters.sourceCustomerIds && filters.sourceCustomerIds.length > 0) {
+        params.sourceCustomerIds = JSON.stringify(filters.sourceCustomerIds);
+    }
     return params;
 }
 function filtersToCustomerListQuery(filters) {
     var _a;
     let excludeFilters = buildExcludeFilters(filters);
+    let sourceCustomerType = getSourceCustomerType(filters);
     let query = {
-        role: (_a = filters.role) !== null && _a !== void 0 ? _a : "both",
+        role: getRole(filters),
     };
     let filter = buildFilterExpression(filters);
     if (filter) {
@@ -637,10 +673,26 @@ function filtersToCustomerListQuery(filters) {
     if (filters.rollingDateConfig) {
         query.rollingDateConfig = filters.rollingDateConfig;
     }
+    if (sourceCustomerType) {
+        query.sourceCustomerType = sourceCustomerType;
+    }
+    if (filters.sourceSaleId) {
+        query.sourceSaleId = filters.sourceSaleId;
+    }
+    if (filters.sourceCustomerIds && filters.sourceCustomerIds.length > 0) {
+        query.sourceCustomerIds = [...filters.sourceCustomerIds];
+    }
     if (filters.secondaryFilter) {
+        let secondarySourceCustomerType = getSourceCustomerType(filters.secondaryFilter);
         query.secondaryFilter = {
-            role: filters.secondaryFilter.role,
+            role: getRole(filters.secondaryFilter),
             filter: buildFilterExpression(filters.secondaryFilter),
+            ...(secondarySourceCustomerType
+                ? { sourceCustomerType: secondarySourceCustomerType }
+                : {}),
+            ...(((_a = filters.secondaryFilter.sourceCustomerIds) === null || _a === void 0 ? void 0 : _a.length)
+                ? { sourceCustomerIds: [...filters.secondaryFilter.sourceCustomerIds] }
+                : {}),
             ...(filters.secondaryFilter.geoBounds
                 ? { bounds: filters.secondaryFilter.geoBounds }
                 : {}),
@@ -652,14 +704,27 @@ function filtersToCustomerListQuery(filters) {
     return query;
 }
 function queryToFilters(query) {
+    var _a, _b;
     if (!query) {
         return { role: "both", productCodes: [] };
     }
+    let sourceCustomerIds = query.sourceCustomerIds || [];
+    let sourceSaleId = query.sourceSaleId || null;
+    let sourceCustomerType = getSourceCustomerType({
+        sourceCustomerType: query.sourceCustomerType,
+        sourceSaleId,
+        sourceCustomerIds,
+    });
     let filters = {
-        role: query.role,
+        role: query.role || "both",
         dateStart: extractDate(query.filter, ">="),
         dateEnd: extractDate(query.filter, "<="),
         productCodes: extractProductCodes(query.filter),
+        sourceCustomerType,
+        sourceCustomerIds: sourceCustomerIds.length > 0
+            ? sourceCustomerIds
+            : extractSourceCustomerIds(query.filter, sourceCustomerType),
+        sourceSaleId,
         excludedProductCodes: [],
         geoBounds: query.bounds || null,
         boughtOnlineOnly: /@boughtOnline\s*=\s*true/.test(query.filter || ""),
@@ -677,11 +742,20 @@ function queryToFilters(query) {
         filters.excludedProductCodes = uniqueStrings((filters.excludedProductCodes || []).concat(extractProductCodes(excludeFilter)));
     }
     if (query.secondaryFilter) {
+        let secondarySourceCustomerType = getSourceCustomerType(query.secondaryFilter) ||
+            (((_a = query.secondaryFilter.filter) === null || _a === void 0 ? void 0 : _a.includes("sellerCustomerId"))
+                ? "seller"
+                : ((_b = query.secondaryFilter.filter) === null || _b === void 0 ? void 0 : _b.includes("buyerCustomerId"))
+                    ? "buyer"
+                    : null);
         filters.secondaryFilter = {
-            role: query.secondaryFilter.role,
+            role: query.secondaryFilter.role || "both",
             dateStart: extractDate(query.secondaryFilter.filter, ">="),
             dateEnd: extractDate(query.secondaryFilter.filter, "<="),
             productCodes: extractProductCodes(query.secondaryFilter.filter),
+            sourceCustomerType: secondarySourceCustomerType,
+            sourceCustomerIds: query.secondaryFilter.sourceCustomerIds ||
+                extractSourceCustomerIds(query.secondaryFilter.filter, secondarySourceCustomerType),
             geoBounds: query.secondaryFilter.bounds || null,
             rollingDateConfig: query.secondaryFilter.rollingDateConfig,
         };
@@ -698,6 +772,15 @@ function mergeCustomerListFilters(base, updates) {
         merged.dateEnd = updates.dateEnd;
     if (updates.productCodes !== undefined)
         merged.productCodes = [...updates.productCodes];
+    if (updates.sourceCustomerType !== undefined) {
+        merged.sourceCustomerType = updates.sourceCustomerType;
+    }
+    if (updates.sourceCustomerIds !== undefined) {
+        merged.sourceCustomerIds = [...updates.sourceCustomerIds];
+    }
+    if (updates.sourceSaleId !== undefined) {
+        merged.sourceSaleId = updates.sourceSaleId;
+    }
     if (updates.excludeDateStart !== undefined) {
         merged.excludeDateStart = updates.excludeDateStart;
     }
@@ -728,7 +811,10 @@ function mergeCustomerListFilters(base, updates) {
         else {
             let nextSecondary = merged.secondaryFilter
                 ? { ...merged.secondaryFilter }
-                : { role: updates.secondaryFilter.role || "both", productCodes: [] };
+                : {
+                    role: updates.secondaryFilter.role || "both",
+                    productCodes: [],
+                };
             if (updates.secondaryFilter.role !== undefined) {
                 nextSecondary.role = updates.secondaryFilter.role;
             }
@@ -741,6 +827,15 @@ function mergeCustomerListFilters(base, updates) {
             if (updates.secondaryFilter.productCodes !== undefined) {
                 nextSecondary.productCodes = [...updates.secondaryFilter.productCodes];
             }
+            if (updates.secondaryFilter.sourceCustomerType !== undefined) {
+                nextSecondary.sourceCustomerType =
+                    updates.secondaryFilter.sourceCustomerType;
+            }
+            if (updates.secondaryFilter.sourceCustomerIds !== undefined) {
+                nextSecondary.sourceCustomerIds = [
+                    ...updates.secondaryFilter.sourceCustomerIds,
+                ];
+            }
             if (updates.secondaryFilter.geoBounds !== undefined) {
                 nextSecondary.geoBounds = updates.secondaryFilter.geoBounds;
             }
@@ -780,6 +875,7 @@ function buildExcludeFilters(filters) {
     return excludeFilters;
 }
 function buildFilterExpression(filters) {
+    var _a;
     let fixedClauses = [];
     let alternativeGroups = [];
     if (filters.dateStart)
@@ -789,6 +885,12 @@ function buildFilterExpression(filters) {
     if (filters.productCodes && filters.productCodes.length > 0) {
         alternativeGroups.push(filters.productCodes.map((code) => `productCode = "${code}"`));
     }
+    if (!filters.sourceSaleId &&
+        filters.sourceCustomerType &&
+        ((_a = filters.sourceCustomerIds) === null || _a === void 0 ? void 0 : _a.length)) {
+        let sourceCustomerIdField = getSourceCustomerIdField(filters.sourceCustomerType);
+        alternativeGroups.push(filters.sourceCustomerIds.map((id) => `${sourceCustomerIdField} = "${id.replace(/"/g, '\\"')}"`));
+    }
     if (filters.boughtOnlineOnly) {
         fixedClauses.push(`@boughtOnline = true`);
     }
@@ -930,6 +1032,21 @@ function extractProductCodes(filter) {
     }
     return uniqueStrings(extractAllMatches(filter, /productCode\s*=\s*"([^"]+)"/g));
 }
+function extractSourceCustomerIds(filter, sourceCustomerType) {
+    if (!filter || !sourceCustomerType) {
+        return [];
+    }
+    let fieldName = getSourceCustomerIdField(sourceCustomerType);
+    let escapedFieldName = fieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    let inMatch = filter.match(new RegExp(`${escapedFieldName}\\s+IN\\s*\\(([^)]+)\\)`));
+    if (inMatch) {
+        return uniqueStrings(inMatch[1]
+            .split(",")
+            .map((value) => value.trim().replace(/^"|"$/g, ""))
+            .filter(Boolean));
+    }
+    return uniqueStrings(extractAllMatches(filter, new RegExp(`${escapedFieldName}\\s*=\\s*"([^"]+)"`, "g")));
+}
 function extractAllMatches(filter, regex) {
     if (!filter) {
         return [];
@@ -951,7 +1068,7 @@ function isRateLimitError(error) {
 
 var util;
 (function (util) {
-    util.assertEqual = (val) => val;
+    util.assertEqual = (_) => { };
     function assertIs(_arg) { }
     util.assertIs = assertIs;
     function assertNever(_x) {
@@ -998,11 +1115,9 @@ var util;
     };
     util.isInteger = typeof Number.isInteger === "function"
         ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
-        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
     function joinValues(array, separator = " | ") {
-        return array
-            .map((val) => (typeof val === "string" ? `'${val}'` : val))
-            .join(separator);
+        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
     }
     util.joinValues = joinValues;
     util.jsonStringifyReplacer = (_, value) => {
@@ -1051,7 +1166,7 @@ const getParsedType = (data) => {
         case "string":
             return ZodParsedType.string;
         case "number":
-            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+            return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
         case "boolean":
             return ZodParsedType.boolean;
         case "function":
@@ -1067,10 +1182,7 @@ const getParsedType = (data) => {
             if (data === null) {
                 return ZodParsedType.null;
             }
-            if (data.then &&
-                typeof data.then === "function" &&
-                data.catch &&
-                typeof data.catch === "function") {
+            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
                 return ZodParsedType.promise;
             }
             if (typeof Map !== "undefined" && data instanceof Map) {
@@ -1106,10 +1218,6 @@ const ZodIssueCode = util.arrayToEnum([
     "not_multiple_of",
     "not_finite",
 ]);
-const quotelessJson = (obj) => {
-    const json = JSON.stringify(obj, null, 2);
-    return json.replace(/"([^"]+)":/g, "$1:");
-};
 class ZodError extends Error {
     get errors() {
         return this.issues;
@@ -1202,8 +1310,9 @@ class ZodError extends Error {
         const formErrors = [];
         for (const sub of this.issues) {
             if (sub.path.length > 0) {
-                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                fieldErrors[sub.path[0]].push(mapper(sub));
+                const firstEl = sub.path[0];
+                fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+                fieldErrors[firstEl].push(mapper(sub));
             }
             else {
                 formErrors.push(mapper(sub));
@@ -1286,17 +1395,11 @@ const errorMap = (issue, _ctx) => {
             else if (issue.type === "string")
                 message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
-                message = `Number must be ${issue.exact
-                    ? `exactly equal to `
-                    : issue.inclusive
-                        ? `greater than or equal to `
-                        : `greater than `}${issue.minimum}`;
+                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+            else if (issue.type === "bigint")
+                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
             else if (issue.type === "date")
-                message = `Date must be ${issue.exact
-                    ? `exactly equal to `
-                    : issue.inclusive
-                        ? `greater than or equal to `
-                        : `greater than `}${new Date(Number(issue.minimum))}`;
+                message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
             else
                 message = "Invalid input";
             break;
@@ -1306,23 +1409,11 @@ const errorMap = (issue, _ctx) => {
             else if (issue.type === "string")
                 message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
-                message = `Number must be ${issue.exact
-                    ? `exactly`
-                    : issue.inclusive
-                        ? `less than or equal to`
-                        : `less than`} ${issue.maximum}`;
+                message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
             else if (issue.type === "bigint")
-                message = `BigInt must be ${issue.exact
-                    ? `exactly`
-                    : issue.inclusive
-                        ? `less than or equal to`
-                        : `less than`} ${issue.maximum}`;
+                message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
             else if (issue.type === "date")
-                message = `Date must be ${issue.exact
-                    ? `exactly`
-                    : issue.inclusive
-                        ? `smaller than or equal to`
-                        : `smaller than`} ${new Date(Number(issue.maximum))}`;
+                message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
             else
                 message = "Invalid input";
             break;
@@ -1346,9 +1437,6 @@ const errorMap = (issue, _ctx) => {
 };
 
 let overrideErrorMap = errorMap;
-function setErrorMap(map) {
-    overrideErrorMap = map;
-}
 function getErrorMap() {
     return overrideErrorMap;
 }
@@ -1381,7 +1469,6 @@ const makeIssue = (params) => {
         message: errorMessage,
     };
 };
-const EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
     const overrideMap = getErrorMap();
     const issue = makeIssue({
@@ -1444,8 +1531,7 @@ class ParseStatus {
                 status.dirty();
             if (value.status === "dirty")
                 status.dirty();
-            if (key.value !== "__proto__" &&
-                (typeof value.value !== "undefined" || pair.alwaysSet)) {
+            if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
                 finalObject[key.value] = value.value;
             }
         }
@@ -1462,43 +1548,13 @@ const isDirty = (x) => x.status === "dirty";
 const isValid = (x) => x.status === "valid";
 const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 var errorUtil;
 (function (errorUtil) {
     errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+    // biome-ignore lint:
+    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-var _ZodEnum_cache, _ZodNativeEnum_cache;
 class ParseInputLazyPath {
     constructor(parent, value, path, key) {
         this._cachedPath = [];
@@ -1509,7 +1565,7 @@ class ParseInputLazyPath {
     }
     get path() {
         if (!this._cachedPath.length) {
-            if (this._key instanceof Array) {
+            if (Array.isArray(this._key)) {
                 this._cachedPath.push(...this._path, ...this._key);
             }
             else {
@@ -1549,17 +1605,16 @@ function processCreateParams(params) {
     if (errorMap)
         return { errorMap: errorMap, description };
     const customMap = (iss, ctx) => {
-        var _a, _b;
         const { message } = params;
         if (iss.code === "invalid_enum_value") {
-            return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
+            return { message: message ?? ctx.defaultError };
         }
         if (typeof ctx.data === "undefined") {
-            return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
+            return { message: message ?? required_error ?? ctx.defaultError };
         }
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
-        return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
+        return { message: message ?? invalid_type_error ?? ctx.defaultError };
     };
     return { errorMap: customMap, description };
 }
@@ -1611,14 +1666,13 @@ class ZodType {
         throw result.error;
     }
     safeParse(data, params) {
-        var _a;
         const ctx = {
             common: {
                 issues: [],
-                async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                async: params?.async ?? false,
+                contextualErrorMap: params?.errorMap,
             },
-            path: (params === null || params === void 0 ? void 0 : params.path) || [],
+            path: params?.path || [],
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
@@ -1628,7 +1682,6 @@ class ZodType {
         return handleResult(ctx, result);
     }
     "~validate"(data) {
-        var _a, _b;
         const ctx = {
             common: {
                 issues: [],
@@ -1652,7 +1705,7 @@ class ZodType {
                     };
             }
             catch (err) {
-                if ((_b = (_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes("encountered")) {
+                if (err?.message?.toLowerCase()?.includes("encountered")) {
                     this["~standard"].async = true;
                 }
                 ctx.common = {
@@ -1679,19 +1732,17 @@ class ZodType {
         const ctx = {
             common: {
                 issues: [],
-                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                contextualErrorMap: params?.errorMap,
                 async: true,
             },
-            path: (params === null || params === void 0 ? void 0 : params.path) || [],
+            path: params?.path || [],
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
             parsedType: getParsedType(data),
         };
         const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
-        const result = await (isAsync(maybeAsyncResult)
-            ? maybeAsyncResult
-            : Promise.resolve(maybeAsyncResult));
+        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
         return handleResult(ctx, result);
     }
     refine(check, message) {
@@ -1735,9 +1786,7 @@ class ZodType {
     refinement(check, refinementData) {
         return this._refinement((val, ctx) => {
             if (!check(val)) {
-                ctx.addIssue(typeof refinementData === "function"
-                    ? refinementData(val, ctx)
-                    : refinementData);
+                ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
                 return false;
             }
             else {
@@ -1909,15 +1958,15 @@ const base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z
 const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
 const dateRegex = new RegExp(`^${dateRegexSource}$`);
 function timeRegexSource(args) {
-    // let regex = `\\d{2}:\\d{2}:\\d{2}`;
-    let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
+    let secondsRegexSource = `[0-5]\\d`;
     if (args.precision) {
-        regex = `${regex}\\.\\d{${args.precision}}`;
+        secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
     }
     else if (args.precision == null) {
-        regex = `${regex}(\\.\\d+)?`;
+        secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
     }
-    return regex;
+    const secondsQuantifier = args.precision ? "+" : "?"; // require seconds if precision is nonzero
+    return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
 }
 function timeRegex(args) {
     return new RegExp(`^${timeRegexSource(args)}$`);
@@ -1946,6 +1995,8 @@ function isValidJWT(jwt, alg) {
         return false;
     try {
         const [header] = jwt.split(".");
+        if (!header)
+            return false;
         // Convert base64url to base64
         const base64 = header
             .replace(/-/g, "+")
@@ -1954,13 +2005,15 @@ function isValidJWT(jwt, alg) {
         const decoded = JSON.parse(atob(base64));
         if (typeof decoded !== "object" || decoded === null)
             return false;
-        if (!decoded.typ || !decoded.alg)
+        if ("typ" in decoded && decoded?.typ !== "JWT")
+            return false;
+        if (!decoded.alg)
             return false;
         if (alg && decoded.alg !== alg)
             return false;
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -2131,7 +2184,7 @@ class ZodString extends ZodType {
                 try {
                     new URL(input.data);
                 }
-                catch (_a) {
+                catch {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "url",
@@ -2361,7 +2414,6 @@ class ZodString extends ZodType {
         return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
     }
     datetime(options) {
-        var _a, _b;
         if (typeof options === "string") {
             return this._addCheck({
                 kind: "datetime",
@@ -2373,10 +2425,10 @@ class ZodString extends ZodType {
         }
         return this._addCheck({
             kind: "datetime",
-            precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
-            offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
-            local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            precision: typeof options?.precision === "undefined" ? null : options?.precision,
+            offset: options?.offset ?? false,
+            local: options?.local ?? false,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     date(message) {
@@ -2392,8 +2444,8 @@ class ZodString extends ZodType {
         }
         return this._addCheck({
             kind: "time",
-            precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            precision: typeof options?.precision === "undefined" ? null : options?.precision,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     duration(message) {
@@ -2410,8 +2462,8 @@ class ZodString extends ZodType {
         return this._addCheck({
             kind: "includes",
             value: value,
-            position: options === null || options === void 0 ? void 0 : options.position,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            position: options?.position,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     startsWith(value, message) {
@@ -2544,11 +2596,10 @@ class ZodString extends ZodType {
     }
 }
 ZodString.create = (params) => {
-    var _a;
     return new ZodString({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodString,
-        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+        coerce: params?.coerce ?? false,
         ...processCreateParams(params),
     });
 };
@@ -2557,9 +2608,9 @@ function floatSafeRemainder(val, step) {
     const valDecCount = (val.toString().split(".")[1] || "").length;
     const stepDecCount = (step.toString().split(".")[1] || "").length;
     const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-    const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
-    const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
-    return (valInt % stepInt) / Math.pow(10, decCount);
+    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+    return (valInt % stepInt) / 10 ** decCount;
 }
 class ZodNumber extends ZodType {
     constructor() {
@@ -2598,9 +2649,7 @@ class ZodNumber extends ZodType {
                 }
             }
             else if (check.kind === "min") {
-                const tooSmall = check.inclusive
-                    ? input.data < check.value
-                    : input.data <= check.value;
+                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
                 if (tooSmall) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -2615,9 +2664,7 @@ class ZodNumber extends ZodType {
                 }
             }
             else if (check.kind === "max") {
-                const tooBig = check.inclusive
-                    ? input.data > check.value
-                    : input.data >= check.value;
+                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
                 if (tooBig) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -2775,15 +2822,13 @@ class ZodNumber extends ZodType {
         return max;
     }
     get isInt() {
-        return !!this._def.checks.find((ch) => ch.kind === "int" ||
-            (ch.kind === "multipleOf" && util.isInteger(ch.value)));
+        return !!this._def.checks.find((ch) => ch.kind === "int" || (ch.kind === "multipleOf" && util.isInteger(ch.value)));
     }
     get isFinite() {
-        let max = null, min = null;
+        let max = null;
+        let min = null;
         for (const ch of this._def.checks) {
-            if (ch.kind === "finite" ||
-                ch.kind === "int" ||
-                ch.kind === "multipleOf") {
+            if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
                 return true;
             }
             else if (ch.kind === "min") {
@@ -2802,7 +2847,7 @@ ZodNumber.create = (params) => {
     return new ZodNumber({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodNumber,
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        coerce: params?.coerce || false,
         ...processCreateParams(params),
     });
 };
@@ -2817,7 +2862,7 @@ class ZodBigInt extends ZodType {
             try {
                 input.data = BigInt(input.data);
             }
-            catch (_a) {
+            catch {
                 return this._getInvalidInput(input);
             }
         }
@@ -2829,9 +2874,7 @@ class ZodBigInt extends ZodType {
         const status = new ParseStatus();
         for (const check of this._def.checks) {
             if (check.kind === "min") {
-                const tooSmall = check.inclusive
-                    ? input.data < check.value
-                    : input.data <= check.value;
+                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
                 if (tooSmall) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -2845,9 +2888,7 @@ class ZodBigInt extends ZodType {
                 }
             }
             else if (check.kind === "max") {
-                const tooBig = check.inclusive
-                    ? input.data > check.value
-                    : input.data >= check.value;
+                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
                 if (tooBig) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -2979,11 +3020,10 @@ class ZodBigInt extends ZodType {
     }
 }
 ZodBigInt.create = (params) => {
-    var _a;
     return new ZodBigInt({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodBigInt,
-        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+        coerce: params?.coerce ?? false,
         ...processCreateParams(params),
     });
 };
@@ -3008,7 +3048,7 @@ class ZodBoolean extends ZodType {
 ZodBoolean.create = (params) => {
     return new ZodBoolean({
         typeName: ZodFirstPartyTypeKind.ZodBoolean,
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        coerce: params?.coerce || false,
         ...processCreateParams(params),
     });
 };
@@ -3027,7 +3067,7 @@ class ZodDate extends ZodType {
             });
             return INVALID;
         }
-        if (isNaN(input.data.getTime())) {
+        if (Number.isNaN(input.data.getTime())) {
             const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_date,
@@ -3118,7 +3158,7 @@ class ZodDate extends ZodType {
 ZodDate.create = (params) => {
     return new ZodDate({
         checks: [],
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        coerce: params?.coerce || false,
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -3440,7 +3480,8 @@ class ZodObject extends ZodType {
             return this._cached;
         const shape = this._def.shape();
         const keys = util.objectKeys(shape);
-        return (this._cached = { shape, keys });
+        this._cached = { shape, keys };
+        return this._cached;
     }
     _parse(input) {
         const parsedType = this._getType(input);
@@ -3456,8 +3497,7 @@ class ZodObject extends ZodType {
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
-        if (!(this._def.catchall instanceof ZodNever &&
-            this._def.unknownKeys === "strip")) {
+        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
             for (const key in ctx.data) {
                 if (!shapeKeys.includes(key)) {
                     extraKeys.push(key);
@@ -3545,11 +3585,10 @@ class ZodObject extends ZodType {
             ...(message !== undefined
                 ? {
                     errorMap: (issue, ctx) => {
-                        var _a, _b, _c, _d;
-                        const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
                         if (issue.code === "unrecognized_keys")
                             return {
-                                message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError,
+                                message: errorUtil.errToObj(message).message ?? defaultError,
                             };
                         return {
                             message: defaultError,
@@ -3681,11 +3720,11 @@ class ZodObject extends ZodType {
     }
     pick(mask) {
         const shape = {};
-        util.objectKeys(mask).forEach((key) => {
+        for (const key of util.objectKeys(mask)) {
             if (mask[key] && this.shape[key]) {
                 shape[key] = this.shape[key];
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => shape,
@@ -3693,11 +3732,11 @@ class ZodObject extends ZodType {
     }
     omit(mask) {
         const shape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        for (const key of util.objectKeys(this.shape)) {
             if (!mask[key]) {
                 shape[key] = this.shape[key];
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => shape,
@@ -3711,7 +3750,7 @@ class ZodObject extends ZodType {
     }
     partial(mask) {
         const newShape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        for (const key of util.objectKeys(this.shape)) {
             const fieldSchema = this.shape[key];
             if (mask && !mask[key]) {
                 newShape[key] = fieldSchema;
@@ -3719,7 +3758,7 @@ class ZodObject extends ZodType {
             else {
                 newShape[key] = fieldSchema.optional();
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => newShape,
@@ -3727,7 +3766,7 @@ class ZodObject extends ZodType {
     }
     required(mask) {
         const newShape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        for (const key of util.objectKeys(this.shape)) {
             if (mask && !mask[key]) {
                 newShape[key] = this.shape[key];
             }
@@ -3739,7 +3778,7 @@ class ZodObject extends ZodType {
                 }
                 newShape[key] = newField;
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => newShape,
@@ -3872,137 +3911,6 @@ ZodUnion.create = (types, params) => {
         ...processCreateParams(params),
     });
 };
-/////////////////////////////////////////////////////
-/////////////////////////////////////////////////////
-//////////                                 //////////
-//////////      ZodDiscriminatedUnion      //////////
-//////////                                 //////////
-/////////////////////////////////////////////////////
-/////////////////////////////////////////////////////
-const getDiscriminator = (type) => {
-    if (type instanceof ZodLazy) {
-        return getDiscriminator(type.schema);
-    }
-    else if (type instanceof ZodEffects) {
-        return getDiscriminator(type.innerType());
-    }
-    else if (type instanceof ZodLiteral) {
-        return [type.value];
-    }
-    else if (type instanceof ZodEnum) {
-        return type.options;
-    }
-    else if (type instanceof ZodNativeEnum) {
-        // eslint-disable-next-line ban/ban
-        return util.objectValues(type.enum);
-    }
-    else if (type instanceof ZodDefault) {
-        return getDiscriminator(type._def.innerType);
-    }
-    else if (type instanceof ZodUndefined) {
-        return [undefined];
-    }
-    else if (type instanceof ZodNull) {
-        return [null];
-    }
-    else if (type instanceof ZodOptional) {
-        return [undefined, ...getDiscriminator(type.unwrap())];
-    }
-    else if (type instanceof ZodNullable) {
-        return [null, ...getDiscriminator(type.unwrap())];
-    }
-    else if (type instanceof ZodBranded) {
-        return getDiscriminator(type.unwrap());
-    }
-    else if (type instanceof ZodReadonly) {
-        return getDiscriminator(type.unwrap());
-    }
-    else if (type instanceof ZodCatch) {
-        return getDiscriminator(type._def.innerType);
-    }
-    else {
-        return [];
-    }
-};
-class ZodDiscriminatedUnion extends ZodType {
-    _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.object) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: ZodParsedType.object,
-                received: ctx.parsedType,
-            });
-            return INVALID;
-        }
-        const discriminator = this.discriminator;
-        const discriminatorValue = ctx.data[discriminator];
-        const option = this.optionsMap.get(discriminatorValue);
-        if (!option) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_union_discriminator,
-                options: Array.from(this.optionsMap.keys()),
-                path: [discriminator],
-            });
-            return INVALID;
-        }
-        if (ctx.common.async) {
-            return option._parseAsync({
-                data: ctx.data,
-                path: ctx.path,
-                parent: ctx,
-            });
-        }
-        else {
-            return option._parseSync({
-                data: ctx.data,
-                path: ctx.path,
-                parent: ctx,
-            });
-        }
-    }
-    get discriminator() {
-        return this._def.discriminator;
-    }
-    get options() {
-        return this._def.options;
-    }
-    get optionsMap() {
-        return this._def.optionsMap;
-    }
-    /**
-     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
-     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
-     * have a different value for each object in the union.
-     * @param discriminator the name of the discriminator property
-     * @param types an array of object schemas
-     * @param params
-     */
-    static create(discriminator, options, params) {
-        // Get all the valid discriminator values
-        const optionsMap = new Map();
-        // try {
-        for (const type of options) {
-            const discriminatorValues = getDiscriminator(type.shape[discriminator]);
-            if (!discriminatorValues.length) {
-                throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
-            }
-            for (const value of discriminatorValues) {
-                if (optionsMap.has(value)) {
-                    throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
-                }
-                optionsMap.set(value, type);
-            }
-        }
-        return new ZodDiscriminatedUnion({
-            typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
-            discriminator,
-            options,
-            optionsMap,
-            ...processCreateParams(params),
-        });
-    }
-}
 function mergeValues(a, b) {
     const aType = getParsedType(a);
     const bType = getParsedType(b);
@@ -4011,9 +3919,7 @@ function mergeValues(a, b) {
     }
     else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
         const bKeys = util.objectKeys(b);
-        const sharedKeys = util
-            .objectKeys(a)
-            .filter((key) => bKeys.indexOf(key) !== -1);
+        const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
         const newObj = { ...a, ...b };
         for (const key of sharedKeys) {
             const sharedValue = mergeValues(a[key], b[key]);
@@ -4040,9 +3946,7 @@ function mergeValues(a, b) {
         }
         return { valid: true, data: newArray };
     }
-    else if (aType === ZodParsedType.date &&
-        bType === ZodParsedType.date &&
-        +a === +b) {
+    else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
         return { valid: true, data: a };
     }
     else {
@@ -4103,6 +4007,7 @@ ZodIntersection.create = (left, right, params) => {
         ...processCreateParams(params),
     });
 };
+// type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 class ZodTuple extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
@@ -4173,60 +4078,6 @@ ZodTuple.create = (schemas, params) => {
         ...processCreateParams(params),
     });
 };
-class ZodRecord extends ZodType {
-    get keySchema() {
-        return this._def.keyType;
-    }
-    get valueSchema() {
-        return this._def.valueType;
-    }
-    _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.object) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: ZodParsedType.object,
-                received: ctx.parsedType,
-            });
-            return INVALID;
-        }
-        const pairs = [];
-        const keyType = this._def.keyType;
-        const valueType = this._def.valueType;
-        for (const key in ctx.data) {
-            pairs.push({
-                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
-                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
-                alwaysSet: key in ctx.data,
-            });
-        }
-        if (ctx.common.async) {
-            return ParseStatus.mergeObjectAsync(status, pairs);
-        }
-        else {
-            return ParseStatus.mergeObjectSync(status, pairs);
-        }
-    }
-    get element() {
-        return this._def.valueType;
-    }
-    static create(first, second, third) {
-        if (second instanceof ZodType) {
-            return new ZodRecord({
-                keyType: first,
-                valueType: second,
-                typeName: ZodFirstPartyTypeKind.ZodRecord,
-                ...processCreateParams(third),
-            });
-        }
-        return new ZodRecord({
-            keyType: ZodString.create(),
-            valueType: first,
-            typeName: ZodFirstPartyTypeKind.ZodRecord,
-            ...processCreateParams(second),
-        });
-    }
-}
 class ZodMap extends ZodType {
     get keySchema() {
         return this._def.keyType;
@@ -4380,134 +4231,6 @@ ZodSet.create = (valueType, params) => {
         ...processCreateParams(params),
     });
 };
-class ZodFunction extends ZodType {
-    constructor() {
-        super(...arguments);
-        this.validate = this.implement;
-    }
-    _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.function) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: ZodParsedType.function,
-                received: ctx.parsedType,
-            });
-            return INVALID;
-        }
-        function makeArgsIssue(args, error) {
-            return makeIssue({
-                data: args,
-                path: ctx.path,
-                errorMaps: [
-                    ctx.common.contextualErrorMap,
-                    ctx.schemaErrorMap,
-                    getErrorMap(),
-                    errorMap,
-                ].filter((x) => !!x),
-                issueData: {
-                    code: ZodIssueCode.invalid_arguments,
-                    argumentsError: error,
-                },
-            });
-        }
-        function makeReturnsIssue(returns, error) {
-            return makeIssue({
-                data: returns,
-                path: ctx.path,
-                errorMaps: [
-                    ctx.common.contextualErrorMap,
-                    ctx.schemaErrorMap,
-                    getErrorMap(),
-                    errorMap,
-                ].filter((x) => !!x),
-                issueData: {
-                    code: ZodIssueCode.invalid_return_type,
-                    returnTypeError: error,
-                },
-            });
-        }
-        const params = { errorMap: ctx.common.contextualErrorMap };
-        const fn = ctx.data;
-        if (this._def.returns instanceof ZodPromise) {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const me = this;
-            return OK(async function (...args) {
-                const error = new ZodError([]);
-                const parsedArgs = await me._def.args
-                    .parseAsync(args, params)
-                    .catch((e) => {
-                    error.addIssue(makeArgsIssue(args, e));
-                    throw error;
-                });
-                const result = await Reflect.apply(fn, this, parsedArgs);
-                const parsedReturns = await me._def.returns._def.type
-                    .parseAsync(result, params)
-                    .catch((e) => {
-                    error.addIssue(makeReturnsIssue(result, e));
-                    throw error;
-                });
-                return parsedReturns;
-            });
-        }
-        else {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const me = this;
-            return OK(function (...args) {
-                const parsedArgs = me._def.args.safeParse(args, params);
-                if (!parsedArgs.success) {
-                    throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
-                }
-                const result = Reflect.apply(fn, this, parsedArgs.data);
-                const parsedReturns = me._def.returns.safeParse(result, params);
-                if (!parsedReturns.success) {
-                    throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
-                }
-                return parsedReturns.data;
-            });
-        }
-    }
-    parameters() {
-        return this._def.args;
-    }
-    returnType() {
-        return this._def.returns;
-    }
-    args(...items) {
-        return new ZodFunction({
-            ...this._def,
-            args: ZodTuple.create(items).rest(ZodUnknown.create()),
-        });
-    }
-    returns(returnType) {
-        return new ZodFunction({
-            ...this._def,
-            returns: returnType,
-        });
-    }
-    implement(func) {
-        const validatedFunc = this.parse(func);
-        return validatedFunc;
-    }
-    strictImplement(func) {
-        const validatedFunc = this.parse(func);
-        return validatedFunc;
-    }
-    static create(args, returns, params) {
-        return new ZodFunction({
-            args: (args
-                ? args
-                : ZodTuple.create([]).rest(ZodUnknown.create())),
-            returns: returns || ZodUnknown.create(),
-            typeName: ZodFirstPartyTypeKind.ZodFunction,
-            ...processCreateParams(params),
-        });
-    }
-}
 class ZodLazy extends ZodType {
     get schema() {
         return this._def.getter();
@@ -4557,10 +4280,6 @@ function createZodEnum(values, params) {
     });
 }
 class ZodEnum extends ZodType {
-    constructor() {
-        super(...arguments);
-        _ZodEnum_cache.set(this, void 0);
-    }
     _parse(input) {
         if (typeof input.data !== "string") {
             const ctx = this._getOrReturnCtx(input);
@@ -4572,10 +4291,10 @@ class ZodEnum extends ZodType {
             });
             return INVALID;
         }
-        if (!__classPrivateFieldGet(this, _ZodEnum_cache)) {
-            __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values));
+        if (!this._cache) {
+            this._cache = new Set(this._def.values);
         }
-        if (!__classPrivateFieldGet(this, _ZodEnum_cache).has(input.data)) {
+        if (!this._cache.has(input.data)) {
             const ctx = this._getOrReturnCtx(input);
             const expectedValues = this._def.values;
             addIssueToContext(ctx, {
@@ -4624,18 +4343,12 @@ class ZodEnum extends ZodType {
         });
     }
 }
-_ZodEnum_cache = new WeakMap();
 ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
-    constructor() {
-        super(...arguments);
-        _ZodNativeEnum_cache.set(this, void 0);
-    }
     _parse(input) {
         const nativeEnumValues = util.getValidEnumValues(this._def.values);
         const ctx = this._getOrReturnCtx(input);
-        if (ctx.parsedType !== ZodParsedType.string &&
-            ctx.parsedType !== ZodParsedType.number) {
+        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
             const expectedValues = util.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
                 expected: util.joinValues(expectedValues),
@@ -4644,10 +4357,10 @@ class ZodNativeEnum extends ZodType {
             });
             return INVALID;
         }
-        if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache)) {
-            __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)));
+        if (!this._cache) {
+            this._cache = new Set(util.getValidEnumValues(this._def.values));
         }
-        if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache).has(input.data)) {
+        if (!this._cache.has(input.data)) {
             const expectedValues = util.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
                 received: ctx.data,
@@ -4662,7 +4375,6 @@ class ZodNativeEnum extends ZodType {
         return this._def.values;
     }
 }
-_ZodNativeEnum_cache = new WeakMap();
 ZodNativeEnum.create = (values, params) => {
     return new ZodNativeEnum({
         values: values,
@@ -4676,8 +4388,7 @@ class ZodPromise extends ZodType {
     }
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.promise &&
-            ctx.common.async === false) {
+        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.promise,
@@ -4685,9 +4396,7 @@ class ZodPromise extends ZodType {
             });
             return INVALID;
         }
-        const promisified = ctx.parsedType === ZodParsedType.promise
-            ? ctx.data
-            : Promise.resolve(ctx.data);
+        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
         return OK(promisified.then((data) => {
             return this._def.type.parseAsync(data, {
                 path: ctx.path,
@@ -4793,9 +4502,7 @@ class ZodEffects extends ZodType {
                 return { status: status.value, value: inner.value };
             }
             else {
-                return this._def.schema
-                    ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
-                    .then((inner) => {
+                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
                     if (inner.status === "aborted")
                         return INVALID;
                     if (inner.status === "dirty")
@@ -4814,7 +4521,7 @@ class ZodEffects extends ZodType {
                     parent: ctx,
                 });
                 if (!isValid(base))
-                    return base;
+                    return INVALID;
                 const result = effect.transform(base.value, checkCtx);
                 if (result instanceof Promise) {
                     throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
@@ -4822,12 +4529,13 @@ class ZodEffects extends ZodType {
                 return { status: status.value, value: result };
             }
             else {
-                return this._def.schema
-                    ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
-                    .then((base) => {
+                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
                     if (!isValid(base))
-                        return base;
-                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
+                        return INVALID;
+                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+                        status: status.value,
+                        value: result,
+                    }));
                 });
             }
         }
@@ -4909,9 +4617,7 @@ ZodDefault.create = (type, params) => {
     return new ZodDefault({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodDefault,
-        defaultValue: typeof params.default === "function"
-            ? params.default
-            : () => params.default,
+        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
         ...processCreateParams(params),
     });
 };
@@ -4995,7 +4701,6 @@ ZodNaN.create = (params) => {
         ...processCreateParams(params),
     });
 };
-const BRAND = Symbol("zod_brand");
 class ZodBranded extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
@@ -5077,9 +4782,7 @@ class ZodReadonly extends ZodType {
             }
             return data;
         };
-        return isAsync(result)
-            ? result.then((data) => freeze(data))
-            : freeze(result);
+        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
     }
     unwrap() {
         return this._def.innerType;
@@ -5092,60 +4795,6 @@ ZodReadonly.create = (type, params) => {
         ...processCreateParams(params),
     });
 };
-////////////////////////////////////////
-////////////////////////////////////////
-//////////                    //////////
-//////////      z.custom      //////////
-//////////                    //////////
-////////////////////////////////////////
-////////////////////////////////////////
-function cleanParams(params, data) {
-    const p = typeof params === "function"
-        ? params(data)
-        : typeof params === "string"
-            ? { message: params }
-            : params;
-    const p2 = typeof p === "string" ? { message: p } : p;
-    return p2;
-}
-function custom(check, _params = {}, 
-/**
- * @deprecated
- *
- * Pass `fatal` into the params object instead:
- *
- * ```ts
- * z.string().custom((val) => val.length > 5, { fatal: false })
- * ```
- *
- */
-fatal) {
-    if (check)
-        return ZodAny.create().superRefine((data, ctx) => {
-            var _a, _b;
-            const r = check(data);
-            if (r instanceof Promise) {
-                return r.then((r) => {
-                    var _a, _b;
-                    if (!r) {
-                        const params = cleanParams(_params, data);
-                        const _fatal = (_b = (_a = params.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-                        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-                    }
-                });
-            }
-            if (!r) {
-                const params = cleanParams(_params, data);
-                const _fatal = (_b = (_a = params.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-                ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-            }
-            return;
-        });
-    return ZodAny.create();
-}
-const late = {
-    object: ZodObject.lazycreate,
-};
 var ZodFirstPartyTypeKind;
 (function (ZodFirstPartyTypeKind) {
     ZodFirstPartyTypeKind["ZodString"] = "ZodString";
@@ -5185,170 +4834,17 @@ var ZodFirstPartyTypeKind;
     ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
     ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-const instanceOfType = (
-// const instanceOfType = <T extends new (...args: any[]) => any>(
-cls, params = {
-    message: `Input not instance of ${cls.name}`,
-}) => custom((data) => data instanceof cls, params);
 const stringType = ZodString.create;
-const numberType = ZodNumber.create;
-const nanType = ZodNaN.create;
-const bigIntType = ZodBigInt.create;
-const booleanType = ZodBoolean.create;
-const dateType = ZodDate.create;
-const symbolType = ZodSymbol.create;
-const undefinedType = ZodUndefined.create;
-const nullType = ZodNull.create;
-const anyType = ZodAny.create;
-const unknownType = ZodUnknown.create;
-const neverType = ZodNever.create;
-const voidType = ZodVoid.create;
-const arrayType = ZodArray.create;
+ZodNever.create;
+ZodArray.create;
 const objectType = ZodObject.create;
-const strictObjectType = ZodObject.strictCreate;
-const unionType = ZodUnion.create;
-const discriminatedUnionType = ZodDiscriminatedUnion.create;
-const intersectionType = ZodIntersection.create;
-const tupleType = ZodTuple.create;
-const recordType = ZodRecord.create;
-const mapType = ZodMap.create;
-const setType = ZodSet.create;
-const functionType = ZodFunction.create;
-const lazyType = ZodLazy.create;
-const literalType = ZodLiteral.create;
+ZodUnion.create;
+ZodIntersection.create;
+ZodTuple.create;
 const enumType = ZodEnum.create;
-const nativeEnumType = ZodNativeEnum.create;
-const promiseType = ZodPromise.create;
-const effectsType = ZodEffects.create;
-const optionalType = ZodOptional.create;
-const nullableType = ZodNullable.create;
-const preprocessType = ZodEffects.createWithPreprocess;
-const pipelineType = ZodPipeline.create;
-const ostring = () => stringType().optional();
-const onumber = () => numberType().optional();
-const oboolean = () => booleanType().optional();
-const coerce = {
-    string: ((arg) => ZodString.create({ ...arg, coerce: true })),
-    number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
-    boolean: ((arg) => ZodBoolean.create({
-        ...arg,
-        coerce: true,
-    })),
-    bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
-    date: ((arg) => ZodDate.create({ ...arg, coerce: true })),
-};
-const NEVER = INVALID;
-
-var z = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    defaultErrorMap: errorMap,
-    setErrorMap: setErrorMap,
-    getErrorMap: getErrorMap,
-    makeIssue: makeIssue,
-    EMPTY_PATH: EMPTY_PATH,
-    addIssueToContext: addIssueToContext,
-    ParseStatus: ParseStatus,
-    INVALID: INVALID,
-    DIRTY: DIRTY,
-    OK: OK,
-    isAborted: isAborted,
-    isDirty: isDirty,
-    isValid: isValid,
-    isAsync: isAsync,
-    get util () { return util; },
-    get objectUtil () { return objectUtil; },
-    ZodParsedType: ZodParsedType,
-    getParsedType: getParsedType,
-    ZodType: ZodType,
-    datetimeRegex: datetimeRegex,
-    ZodString: ZodString,
-    ZodNumber: ZodNumber,
-    ZodBigInt: ZodBigInt,
-    ZodBoolean: ZodBoolean,
-    ZodDate: ZodDate,
-    ZodSymbol: ZodSymbol,
-    ZodUndefined: ZodUndefined,
-    ZodNull: ZodNull,
-    ZodAny: ZodAny,
-    ZodUnknown: ZodUnknown,
-    ZodNever: ZodNever,
-    ZodVoid: ZodVoid,
-    ZodArray: ZodArray,
-    ZodObject: ZodObject,
-    ZodUnion: ZodUnion,
-    ZodDiscriminatedUnion: ZodDiscriminatedUnion,
-    ZodIntersection: ZodIntersection,
-    ZodTuple: ZodTuple,
-    ZodRecord: ZodRecord,
-    ZodMap: ZodMap,
-    ZodSet: ZodSet,
-    ZodFunction: ZodFunction,
-    ZodLazy: ZodLazy,
-    ZodLiteral: ZodLiteral,
-    ZodEnum: ZodEnum,
-    ZodNativeEnum: ZodNativeEnum,
-    ZodPromise: ZodPromise,
-    ZodEffects: ZodEffects,
-    ZodTransformer: ZodEffects,
-    ZodOptional: ZodOptional,
-    ZodNullable: ZodNullable,
-    ZodDefault: ZodDefault,
-    ZodCatch: ZodCatch,
-    ZodNaN: ZodNaN,
-    BRAND: BRAND,
-    ZodBranded: ZodBranded,
-    ZodPipeline: ZodPipeline,
-    ZodReadonly: ZodReadonly,
-    custom: custom,
-    Schema: ZodType,
-    ZodSchema: ZodType,
-    late: late,
-    get ZodFirstPartyTypeKind () { return ZodFirstPartyTypeKind; },
-    coerce: coerce,
-    any: anyType,
-    array: arrayType,
-    bigint: bigIntType,
-    boolean: booleanType,
-    date: dateType,
-    discriminatedUnion: discriminatedUnionType,
-    effect: effectsType,
-    'enum': enumType,
-    'function': functionType,
-    'instanceof': instanceOfType,
-    intersection: intersectionType,
-    lazy: lazyType,
-    literal: literalType,
-    map: mapType,
-    nan: nanType,
-    nativeEnum: nativeEnumType,
-    never: neverType,
-    'null': nullType,
-    nullable: nullableType,
-    number: numberType,
-    object: objectType,
-    oboolean: oboolean,
-    onumber: onumber,
-    optional: optionalType,
-    ostring: ostring,
-    pipeline: pipelineType,
-    preprocess: preprocessType,
-    promise: promiseType,
-    record: recordType,
-    set: setType,
-    strictObject: strictObjectType,
-    string: stringType,
-    symbol: symbolType,
-    transformer: effectsType,
-    tuple: tupleType,
-    'undefined': undefinedType,
-    union: unionType,
-    unknown: unknownType,
-    'void': voidType,
-    NEVER: NEVER,
-    ZodIssueCode: ZodIssueCode,
-    quotelessJson: quotelessJson,
-    ZodError: ZodError
-});
+ZodPromise.create;
+ZodOptional.create;
+ZodNullable.create;
 
 const BASE_CF_URL = "https://mediacrate.marteye.ie";
 /**
@@ -5356,9 +4852,9 @@ const BASE_CF_URL = "https://mediacrate.marteye.ie";
 | START OF MEDIA CRATE CODE
 |--------------------------------------------------
 */
-z.object({
-    assetPath: z.string().url({ message: "URL is required" }),
-    suffix: z.string().min(1, { message: "Suffix Type is required" }),
+objectType({
+    assetPath: stringType().url({ message: "URL is required" }),
+    suffix: stringType().min(1, { message: "Suffix Type is required" }),
 });
 // Adding Sizes here will make more end points in the mainConfig object
 const IMAGE_SIZES_VALUES$1 = [
@@ -5368,8 +4864,8 @@ const IMAGE_SIZES_VALUES$1 = [
     "large",
 ];
 const VIDEO_TASKS_VALUES$1 = ["compressed", "thumbnail"];
-z.enum(VIDEO_TASKS_VALUES$1);
-z.enum(IMAGE_SIZES_VALUES$1);
+enumType(VIDEO_TASKS_VALUES$1);
+enumType(IMAGE_SIZES_VALUES$1);
 const UPLOAD_PATHS = {
     START_UPLOAD: "startMultipartUpload",
     UPLOAD_PART: "uploadChunk",
@@ -5950,8 +5446,8 @@ function create$a(httpClient) {
 
 function create$9(httpClient) {
     return {
-        list: async (marketId) => {
-            return httpClient.get(`/${marketId}/product-codes`);
+        list: async (marketId, options) => {
+            return httpClient.get(`/${marketId}/product-codes`, (options === null || options === void 0 ? void 0 : options.includeArchived) ? { includeArchived: "true" } : undefined);
         },
         get: async (marketId, id, options) => {
             return httpClient.get(`/${marketId}/product-codes/${id}`, (options === null || options === void 0 ? void 0 : options.at) ? { at: options.at } : undefined);
@@ -6223,6 +5719,7 @@ const SupportedSuperTypes = [
     "Cattle",
     "Pigs",
     "Horses",
+    "Dogs",
     "Deer",
     "Poultry",
     "Machinery",
@@ -6239,6 +5736,12 @@ const LivestockSuperTypes = [
     "Poultry",
 ];
 const SupportedCurrencyCodes = ["GBP", "EUR", "USD"];
+const AccountTiers = {
+    free: 0,
+    basic: 1,
+    standard: 2,
+    premium: 3,
+};
 const SupportedUnitsOfSale = [
     "Per KG",
     "Per Item",
@@ -6290,6 +5793,7 @@ const supportedWebhookEvents = [
 
 var types = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    AccountTiers: AccountTiers,
     IMAGE_SIZES_VALUES: IMAGE_SIZES_VALUES,
     LivestockSuperTypes: LivestockSuperTypes,
     SupportedCurrencyCodes: SupportedCurrencyCodes,
@@ -6361,6 +5865,913 @@ function createAppManifest(appConfig) {
     };
 }
 
+const MEDIA_CRATE_V2_BASE_URL_ENV_VARS = [
+    "MEDIA_CRATE_V2_BASE_URL",
+    "NEXT_PUBLIC_MEDIA_CRATE_BASE_URL",
+];
+const MEDIA_CRATE_SINGLE_UPLOAD_MAX_BYTES = 25 * 1024 * 1024;
+const MEDIA_CRATE_MULTIPART_MAX_CHUNK_BYTES = 100 * 1024 * 1024;
+const MEDIA_CRATE_DEFAULT_CHUNK_BYTES = 5 * 1024 * 1024;
+const MEDIA_CRATE_MEDIA_STATUSES = [
+    "uploading",
+    "processing",
+    "done",
+    "error",
+    "deleted",
+    "partial",
+    "expired",
+    "indeterminate",
+];
+/** @deprecated Use MEDIA_CRATE_MEDIA_STATUSES. */
+const MEDIA_CRATE_ASSET_STATUSES = MEDIA_CRATE_MEDIA_STATUSES;
+function getMediaCrateVariant(source, variantName, opts = {}) {
+    var _a, _b;
+    const urls = getMediaCrateUrls(source);
+    const variant = variantName === "original"
+        ? urls.original
+        : ((_b = (_a = urls.variants) === null || _a === void 0 ? void 0 : _a[variantName]) !== null && _b !== void 0 ? _b : (opts.fallbackToOriginal ? urls.original : undefined));
+    if (!variant) {
+        return undefined;
+    }
+    if (opts.requireReady && !variant.ready) {
+        return undefined;
+    }
+    return variant;
+}
+function getMediaCrateVariantUrl(source, variantName, opts = {}) {
+    var _a;
+    return (_a = getMediaCrateVariant(source, variantName, opts)) === null || _a === void 0 ? void 0 : _a.url;
+}
+function requireMediaCrateVariantUrl(source, variantName, opts = {}) {
+    const url = getMediaCrateVariantUrl(source, variantName, opts);
+    if (!url) {
+        const readyMessage = opts.requireReady ? " ready" : "";
+        throw new Error(`Media Crate did not return a${readyMessage} ${variantName} variant`);
+    }
+    return url;
+}
+class MediaCrateHttpError extends Error {
+    constructor(args) {
+        super(args.message);
+        this.name = "MediaCrateHttpError";
+        this.status = args.status;
+        this.method = args.method;
+        this.url = args.url;
+        this.body = args.body;
+        this.collidingKeys = args.collidingKeys;
+    }
+}
+class MediaCrateUploadSourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MediaCrateUploadSourceError";
+    }
+}
+class InMemoryMediaCrateMultipartSessionStore {
+    constructor() {
+        this.sessions = new Map();
+    }
+    async get(key) {
+        const session = this.sessions.get(key);
+        return session ? copySession(session) : null;
+    }
+    async set(key, session) {
+        this.sessions.set(key, copySession(session));
+    }
+    async delete(key) {
+        this.sessions.delete(key);
+    }
+}
+function createWebUploadSource(file, opts = {}) {
+    var _a, _b, _c, _d, _e;
+    const fileWithMetadata = file;
+    const name = (_b = (_a = opts.name) !== null && _a !== void 0 ? _a : fileWithMetadata.name) !== null && _b !== void 0 ? _b : "asset";
+    const type = (_d = (_c = opts.type) !== null && _c !== void 0 ? _c : file.type) !== null && _d !== void 0 ? _d : "application/octet-stream";
+    const lastModified = (_e = opts.lastModified) !== null && _e !== void 0 ? _e : fileWithMetadata.lastModified;
+    return {
+        name,
+        type,
+        size: file.size,
+        lastModified,
+        fingerprint: opts.fingerprint,
+        canUseSingleUpload: true,
+        async getPart({ start, end }) {
+            return file.slice(start, end, type);
+        },
+    };
+}
+class MediaCrateClient {
+    constructor(opts) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        this.baseUrl = resolveMediaCrateBaseUrl(opts);
+        this.marketId = opts.marketId;
+        this.getFirebaseToken = opts.getFirebaseToken;
+        this.fetchImpl = (_a = opts.fetchImpl) !== null && _a !== void 0 ? _a : getGlobalFetch();
+        this.sessionStore =
+            (_b = opts.sessionStore) !== null && _b !== void 0 ? _b : new InMemoryMediaCrateMultipartSessionStore();
+        this.chunkSizeBytes =
+            (_c = opts.chunkSizeBytes) !== null && _c !== void 0 ? _c : MEDIA_CRATE_DEFAULT_CHUNK_BYTES;
+        this.maxPartAttempts = (_d = opts.maxPartAttempts) !== null && _d !== void 0 ? _d : 3;
+        this.maxFinishAttempts = (_e = opts.maxFinishAttempts) !== null && _e !== void 0 ? _e : 3;
+        this.retryBaseDelayMs = (_f = opts.retryBaseDelayMs) !== null && _f !== void 0 ? _f : 500;
+        this.maxConcurrentParts = (_g = opts.maxConcurrentParts) !== null && _g !== void 0 ? _g : 3;
+        this.defaultUploadStrategy = (_h = opts.defaultUploadStrategy) !== null && _h !== void 0 ? _h : "auto";
+        this.sleep = (_j = opts.sleep) !== null && _j !== void 0 ? _j : defaultSleep;
+        this.now = (_k = opts.now) !== null && _k !== void 0 ? _k : Date.now;
+        this.random = (_l = opts.random) !== null && _l !== void 0 ? _l : Math.random;
+    }
+    createMediaPath(...segments) {
+        if (segments.length === 0) {
+            throw new Error("At least one media path segment is required");
+        }
+        return normalizeUploadPath([
+            normalizeUploadPathSegment(this.marketId, "marketId"),
+            ...segments.map((segment, index) => normalizeUploadPathSegment(segment, `path segment ${index + 1}`)),
+        ].join("/"));
+    }
+    createLotMediaPath(args) {
+        return this.createMediaPath(args.saleId, args.lotId, args.attributeId, args.fileName);
+    }
+    uploadLotMedia(opts) {
+        var _a;
+        const path = this.createLotMediaPath({
+            saleId: opts.saleId,
+            lotId: opts.lotId,
+            attributeId: opts.attributeId,
+            fileName: (_a = opts.fileName) !== null && _a !== void 0 ? _a : opts.source.name,
+        });
+        return this.upload({
+            ...opts,
+            mode: "lot",
+            path,
+        });
+    }
+    uploadMedia(opts) {
+        return this.upload(opts);
+    }
+    async upload(opts) {
+        const path = normalizeUploadPath(opts.path);
+        this.assertPathMatchesMarket(path);
+        const strategy = this.resolveUploadStrategy(opts.strategy, opts.source);
+        if (strategy === "single") {
+            return this.uploadSingle({ ...opts, path });
+        }
+        return this.uploadMultipart({ ...opts, path });
+    }
+    async getStatus(statusUrl) {
+        const headers = await this.createBaseHeaders();
+        const response = await this.fetchImpl(statusUrl, {
+            method: "GET",
+            headers,
+        });
+        await throwIfNotOk(response, "GET", statusUrl);
+        return (await response.json());
+    }
+    async delete(opts) {
+        const url = this.urlFor("/delete");
+        const headers = await this.createBaseHeaders();
+        headers.set("X-Market-Id", this.marketId);
+        headers.set("Content-Type", "application/x-www-form-urlencoded");
+        const body = new URLSearchParams({ fileUrl: opts.fileUrl });
+        const response = await this.fetchImpl(url.toString(), {
+            method: "DELETE",
+            headers,
+            body,
+        });
+        await throwIfNotOk(response, "DELETE", url.toString());
+    }
+    async duplicate(opts) {
+        var _a;
+        const url = this.urlFor("/duplicate");
+        const targetFilePath = normalizeUploadPath(opts.targetFilePath);
+        this.assertPathMatchesMarket(targetFilePath);
+        const headers = await this.createBaseHeaders();
+        headers.set("X-Market-Id", this.marketId);
+        headers.set("Content-Type", "application/json");
+        const response = await this.fetchImpl(url.toString(), {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                sourceUrl: opts.sourceUrl,
+                targetFilePath,
+                targetFileName: opts.targetFileName,
+                overwrite: (_a = opts.overwrite) !== null && _a !== void 0 ? _a : true,
+            }),
+        });
+        await throwIfNotOk(response, "POST", url.toString());
+        return (await response.json());
+    }
+    async cancelMultipartUpload(args) {
+        const path = normalizeUploadPath(args.path);
+        this.assertPathMatchesMarket(path);
+        if (args.mode === "direct") {
+            await this.cancelDirectMultipartUpload({ ...args, path });
+        }
+        else {
+            await this.cancelProcessedMultipartUpload({ ...args, path });
+        }
+        if (args.sessionKey) {
+            await this.sessionStore.delete(args.sessionKey);
+        }
+    }
+    resolveUploadStrategy(strategy, source) {
+        const resolved = strategy !== null && strategy !== void 0 ? strategy : this.defaultUploadStrategy;
+        if (resolved === "single") {
+            return "single";
+        }
+        if (resolved === "multipart") {
+            return "multipart";
+        }
+        if (source.size <= MEDIA_CRATE_SINGLE_UPLOAD_MAX_BYTES &&
+            source.canUseSingleUpload !== false) {
+            return "single";
+        }
+        return "multipart";
+    }
+    async uploadSingle(opts) {
+        var _a, _b, _c, _d;
+        if (opts.source.canUseSingleUpload === false) {
+            throw new MediaCrateUploadSourceError("This upload source cannot be used for single binary uploads. Use multipart instead.");
+        }
+        (_a = opts.onProgress) === null || _a === void 0 ? void 0 : _a.call(opts, {
+            phase: "starting",
+            bytesUploaded: 0,
+            totalBytes: opts.source.size,
+            totalParts: 1,
+            partNumber: 1,
+        });
+        const body = await opts.source.getPart({
+            start: 0,
+            end: opts.source.size,
+            partNumber: 1,
+        });
+        if (isReactNativeFormDataFile(body)) {
+            throw new MediaCrateUploadSourceError("Single binary uploads require raw bytes. Use multipart for URI-backed sources.");
+        }
+        const url = this.urlFor(opts.mode === "direct" ? "/standalone/upload" : "/upload");
+        url.searchParams.set("filePath", opts.path);
+        const headers = await this.createUploadHeaders({
+            mode: opts.mode,
+            overwrite: opts.overwrite,
+            contentType: (_b = opts.source.type) !== null && _b !== void 0 ? _b : "application/octet-stream",
+        });
+        try {
+            const response = await this.fetchImpl(url.toString(), {
+                method: "POST",
+                headers,
+                body: body,
+            });
+            await throwIfNotOk(response, "POST", url.toString());
+            const result = (await response.json());
+            (_c = opts.onProgress) === null || _c === void 0 ? void 0 : _c.call(opts, {
+                phase: "uploaded",
+                bytesUploaded: opts.source.size,
+                totalBytes: opts.source.size,
+                totalParts: 1,
+                partNumber: 1,
+            });
+            return result;
+        }
+        catch (error) {
+            (_d = opts.onProgress) === null || _d === void 0 ? void 0 : _d.call(opts, {
+                phase: "error",
+                bytesUploaded: 0,
+                totalBytes: opts.source.size,
+                totalParts: 1,
+                partNumber: 1,
+            });
+            throw error;
+        }
+    }
+    async uploadMultipart(opts) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const chunkSize = (_a = opts.chunkSizeBytes) !== null && _a !== void 0 ? _a : this.chunkSizeBytes;
+        assertValidChunkSize(chunkSize);
+        const totalParts = Math.ceil(opts.source.size / chunkSize);
+        const sessionKey = (_b = opts.sessionKey) !== null && _b !== void 0 ? _b : createMultipartSessionKey({
+            baseUrl: this.baseUrl,
+            marketId: this.marketId,
+            mode: opts.mode,
+            path: opts.path,
+            source: opts.source,
+            chunkSize,
+            overwrite: (_c = opts.overwrite) !== null && _c !== void 0 ? _c : false,
+        });
+        let session = await this.getOrStartMultipartSession({
+            ...opts,
+            chunkSize,
+            totalParts,
+            sessionKey,
+        });
+        const completedPartNumbers = new Set(session.sections.map((section) => Number(section.partNumber)));
+        let bytesUploaded = getCompletedBytes({
+            completedPartNumbers,
+            sourceSize: opts.source.size,
+            chunkSize,
+        });
+        if (completedPartNumbers.size > 0) {
+            (_d = opts.onProgress) === null || _d === void 0 ? void 0 : _d.call(opts, {
+                phase: "resuming",
+                bytesUploaded,
+                totalBytes: opts.source.size,
+                totalParts,
+                uploadId: session.uploadId,
+            });
+        }
+        try {
+            const pendingParts = createPendingPartNumbers(totalParts, completedPartNumbers);
+            let nextPendingIndex = 0;
+            const concurrency = Math.max(1, Math.min((_e = opts.maxConcurrentParts) !== null && _e !== void 0 ? _e : this.maxConcurrentParts, pendingParts.length || 1));
+            const uploadNextPart = async () => {
+                var _a;
+                while (nextPendingIndex < pendingParts.length) {
+                    const partNumber = pendingParts[nextPendingIndex];
+                    nextPendingIndex++;
+                    const section = await this.uploadPartWithRetry({
+                        mode: opts.mode,
+                        path: opts.path,
+                        source: opts.source,
+                        uploadId: session.uploadId,
+                        chunkSize,
+                        partNumber,
+                        totalParts,
+                        onProgress: (progress) => {
+                            var _a;
+                            (_a = opts.onProgress) === null || _a === void 0 ? void 0 : _a.call(opts, {
+                                ...progress,
+                                bytesUploaded,
+                                totalBytes: opts.source.size,
+                                uploadId: session.uploadId,
+                            });
+                        },
+                    });
+                    if (!completedPartNumbers.has(partNumber)) {
+                        completedPartNumbers.add(partNumber);
+                        session = {
+                            ...session,
+                            sections: [...session.sections, section],
+                            updatedAt: this.now(),
+                        };
+                        await this.sessionStore.set(sessionKey, session);
+                        bytesUploaded += getPartSize({
+                            partNumber,
+                            sourceSize: opts.source.size,
+                            chunkSize,
+                        });
+                    }
+                    (_a = opts.onProgress) === null || _a === void 0 ? void 0 : _a.call(opts, {
+                        phase: "uploading",
+                        bytesUploaded,
+                        totalBytes: opts.source.size,
+                        partNumber,
+                        totalParts,
+                        uploadId: session.uploadId,
+                    });
+                }
+            };
+            await Promise.all(Array.from({ length: concurrency }, () => uploadNextPart()));
+            (_f = opts.onProgress) === null || _f === void 0 ? void 0 : _f.call(opts, {
+                phase: "finishing",
+                bytesUploaded: opts.source.size,
+                totalBytes: opts.source.size,
+                totalParts,
+                uploadId: session.uploadId,
+            });
+            const result = await this.finishMultipartUploadWithRetry({
+                mode: opts.mode,
+                path: opts.path,
+                fileName: opts.source.name,
+                uploadId: session.uploadId,
+                sections: sortSections(session.sections),
+            });
+            await this.sessionStore.delete(sessionKey);
+            (_g = opts.onProgress) === null || _g === void 0 ? void 0 : _g.call(opts, {
+                phase: "uploaded",
+                bytesUploaded: opts.source.size,
+                totalBytes: opts.source.size,
+                totalParts,
+                uploadId: session.uploadId,
+            });
+            return result;
+        }
+        catch (error) {
+            if (shouldForgetMultipartSession(error)) {
+                await this.sessionStore.delete(sessionKey);
+            }
+            (_h = opts.onProgress) === null || _h === void 0 ? void 0 : _h.call(opts, {
+                phase: "error",
+                bytesUploaded,
+                totalBytes: opts.source.size,
+                totalParts,
+                uploadId: session.uploadId,
+            });
+            throw error;
+        }
+    }
+    async getOrStartMultipartSession(opts) {
+        var _a, _b, _c;
+        const existingSession = await this.sessionStore.get(opts.sessionKey);
+        const sourceFingerprint = getSourceFingerprint(opts.source);
+        if (existingSession &&
+            existingSession.mode === opts.mode &&
+            existingSession.path === opts.path &&
+            existingSession.marketId === this.marketId &&
+            existingSession.chunkSize === opts.chunkSize &&
+            existingSession.totalBytes === opts.source.size &&
+            existingSession.sourceFingerprint === sourceFingerprint &&
+            existingSession.overwrite === ((_a = opts.overwrite) !== null && _a !== void 0 ? _a : false)) {
+            return existingSession;
+        }
+        (_b = opts.onProgress) === null || _b === void 0 ? void 0 : _b.call(opts, {
+            phase: "starting",
+            bytesUploaded: 0,
+            totalBytes: opts.source.size,
+            totalParts: opts.totalParts,
+        });
+        const startResponse = await this.startMultipartUpload({
+            mode: opts.mode,
+            path: opts.path,
+            fileName: opts.source.name,
+            overwrite: opts.overwrite,
+        });
+        const uploadId = getMultipartUploadId(startResponse);
+        if (!uploadId) {
+            throw new Error("Media Crate did not return an uploadId");
+        }
+        const now = this.now();
+        const startResult = hasUploadResultShape(startResponse)
+            ? startResponse
+            : undefined;
+        const session = {
+            key: opts.sessionKey,
+            mode: opts.mode,
+            path: opts.path,
+            marketId: this.marketId,
+            uploadId,
+            chunkSize: opts.chunkSize,
+            totalBytes: opts.source.size,
+            totalParts: opts.totalParts,
+            sourceFingerprint,
+            overwrite: (_c = opts.overwrite) !== null && _c !== void 0 ? _c : false,
+            sections: [],
+            targetKey: getMultipartTargetKey(startResponse),
+            startResult,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.sessionStore.set(opts.sessionKey, session);
+        return session;
+    }
+    async startMultipartUpload(args) {
+        if (args.mode === "direct") {
+            const url = this.urlFor("/standalone/multipart/start");
+            const headers = await this.createUploadHeaders({
+                mode: args.mode,
+                overwrite: args.overwrite,
+                contentType: "application/json",
+            });
+            const response = await this.fetchImpl(url.toString(), {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    filePath: args.path,
+                    fileName: args.fileName,
+                }),
+            });
+            await throwIfNotOk(response, "POST", url.toString());
+            return (await response.json());
+        }
+        const url = this.urlFor("/startMultipartUpload");
+        const headers = await this.createUploadHeaders({
+            mode: args.mode,
+            overwrite: args.overwrite,
+        });
+        const formData = new FormData();
+        formData.append("filePath", args.path);
+        formData.append("fileName", args.fileName);
+        const response = await this.fetchImpl(url.toString(), {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+        await throwIfNotOk(response, "POST", url.toString());
+        return (await response.json());
+    }
+    async uploadPartWithRetry(args) {
+        return this.runWithRetry({
+            attempts: this.maxPartAttempts,
+            onRetry: (attempt) => {
+                args.onProgress({
+                    phase: "retrying",
+                    partNumber: args.partNumber,
+                    totalParts: args.totalParts,
+                    attempt,
+                    uploadId: args.uploadId,
+                });
+            },
+            operation: () => this.uploadMultipartPart(args),
+        });
+    }
+    async uploadMultipartPart(args) {
+        var _a;
+        const start = args.chunkSize * (args.partNumber - 1);
+        const end = Math.min(args.source.size, start + args.chunkSize);
+        const partBody = await args.source.getPart({
+            start,
+            end,
+            partNumber: args.partNumber,
+        });
+        const url = this.urlFor(args.mode === "direct" ? "/standalone/multipart/chunk" : "/uploadChunk");
+        const headers = await this.createUploadHeaders({ mode: args.mode });
+        const formData = new FormData();
+        formData.append("filePath", args.path);
+        formData.append("fileName", args.source.name);
+        formData.append("uploadId", args.uploadId);
+        formData.append("partNumber", String(args.partNumber));
+        appendUploadPart(formData, "file", partBody, args.source.name, args.source.type);
+        const response = await this.fetchImpl(url.toString(), {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+        await throwIfNotOk(response, "POST", url.toString());
+        const json = (await response.json());
+        const eTag = getMultipartPartEtag(json);
+        const partNumber = (_a = getMultipartPartNumber(json)) !== null && _a !== void 0 ? _a : args.partNumber;
+        if (typeof eTag !== "string" || !eTag) {
+            throw new Error(`Media Crate did not return a valid eTag for part ${args.partNumber}`);
+        }
+        return {
+            partNumber: String(partNumber),
+            eTag,
+        };
+    }
+    async finishMultipartUploadWithRetry(args) {
+        return this.runWithRetry({
+            attempts: this.maxFinishAttempts,
+            operation: () => this.finishMultipartUpload(args),
+        });
+    }
+    async finishMultipartUpload(args) {
+        if (args.mode === "direct") {
+            const url = this.urlFor("/standalone/multipart/finish");
+            const headers = await this.createUploadHeaders({
+                mode: args.mode,
+                contentType: "application/json",
+            });
+            const response = await this.fetchImpl(url.toString(), {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    filePath: args.path,
+                    fileName: args.fileName,
+                    uploadId: args.uploadId,
+                    sections: JSON.stringify(args.sections),
+                }),
+            });
+            await throwIfNotOk(response, "POST", url.toString());
+            return (await response.json());
+        }
+        const url = this.urlFor("/finishMultipartUpload");
+        const headers = await this.createUploadHeaders({ mode: args.mode });
+        const formData = new FormData();
+        formData.append("filePath", args.path);
+        formData.append("fileName", args.fileName);
+        formData.append("uploadId", args.uploadId);
+        formData.append("sections", JSON.stringify(args.sections));
+        const response = await this.fetchImpl(url.toString(), {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+        await throwIfNotOk(response, "POST", url.toString());
+        return (await response.json());
+    }
+    async cancelDirectMultipartUpload(args) {
+        const url = this.urlFor("/standalone/multipart/cancel");
+        const headers = await this.createUploadHeaders({
+            mode: args.mode,
+            contentType: "application/json",
+        });
+        const response = await this.fetchImpl(url.toString(), {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                filePath: args.path,
+                fileName: args.fileName,
+                uploadId: args.uploadId,
+            }),
+        });
+        await throwIfNotOk(response, "POST", url.toString());
+    }
+    async cancelProcessedMultipartUpload(args) {
+        const url = this.urlFor("/cancelUpload");
+        const headers = await this.createUploadHeaders({ mode: args.mode });
+        const formData = new FormData();
+        formData.append("filePath", args.path);
+        formData.append("uploadId", args.uploadId);
+        const response = await this.fetchImpl(url.toString(), {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+        await throwIfNotOk(response, "POST", url.toString());
+    }
+    async runWithRetry(args) {
+        var _a;
+        let lastError;
+        for (let attempt = 1; attempt <= args.attempts; attempt++) {
+            try {
+                return await args.operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= args.attempts || !isRetryableError(error)) {
+                    break;
+                }
+                const nextAttempt = attempt + 1;
+                (_a = args.onRetry) === null || _a === void 0 ? void 0 : _a.call(args, nextAttempt, error);
+                await this.sleep(this.getRetryDelay(attempt));
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    getRetryDelay(attempt) {
+        const exponentialDelay = this.retryBaseDelayMs * Math.pow(2, attempt - 1);
+        const jitter = Math.floor(this.random() * this.retryBaseDelayMs);
+        return exponentialDelay + jitter;
+    }
+    async createBaseHeaders() {
+        const token = await this.getFirebaseToken();
+        const headers = new Headers();
+        headers.set("Authorization", `Bearer ${token}`);
+        return headers;
+    }
+    async createUploadHeaders(args) {
+        const headers = await this.createBaseHeaders();
+        headers.set("X-Market-Id", this.marketId);
+        headers.set("X-Asset-Mode", args.mode);
+        if (typeof args.overwrite === "boolean") {
+            headers.set("X-Overwrite", String(args.overwrite));
+        }
+        if (args.contentType) {
+            headers.set("Content-Type", args.contentType);
+        }
+        return headers;
+    }
+    assertPathMatchesMarket(path) {
+        const pathMarketId = path.split("/")[0];
+        if (pathMarketId !== this.marketId) {
+            throw new Error(`Upload path must start with marketId "${this.marketId}". Received "${pathMarketId}".`);
+        }
+    }
+    urlFor(path) {
+        return new URL(path.replace(/^\/+/, ""), `${this.baseUrl}/`);
+    }
+}
+function resolveMediaCrateBaseUrl(opts) {
+    if (typeof opts.baseUrl === "string") {
+        return normalizeBaseUrl(opts.baseUrl, "baseUrl");
+    }
+    return getMediaCrateBaseUrlFromEnv();
+}
+function getMediaCrateBaseUrlFromEnv(env = getProjectEnv()) {
+    for (const envVarName of MEDIA_CRATE_V2_BASE_URL_ENV_VARS) {
+        const value = env[envVarName];
+        if (typeof value !== "undefined") {
+            return normalizeBaseUrl(value, envVarName);
+        }
+    }
+    throw new Error(`Media Crate base URL is required. Pass baseUrl to MediaCrateClient or set one of these environment variables in the host project: ${MEDIA_CRATE_V2_BASE_URL_ENV_VARS.join(", ")}.`);
+}
+function getProjectEnv() {
+    var _a;
+    const globalWithProcess = globalThis;
+    const processEnv = (_a = globalWithProcess.process) === null || _a === void 0 ? void 0 : _a.env;
+    const env = {};
+    for (const envVarName of MEDIA_CRATE_V2_BASE_URL_ENV_VARS) {
+        env[envVarName] = processEnv === null || processEnv === void 0 ? void 0 : processEnv[envVarName];
+    }
+    return env;
+}
+function normalizeBaseUrl(baseUrl, sourceLabel) {
+    const trimmedBaseUrl = baseUrl.trim();
+    if (!trimmedBaseUrl) {
+        throw new Error(`Media Crate ${sourceLabel} must not be empty`);
+    }
+    return trimmedBaseUrl.replace(/\/+$/, "");
+}
+function normalizeUploadPath(path) {
+    const normalizedPath = path.trim().replace(/^\/+/, "");
+    if (!normalizedPath) {
+        throw new Error("Upload path is required");
+    }
+    return normalizedPath;
+}
+function normalizeUploadPathSegment(segment, label) {
+    const normalizedSegment = segment.trim().replace(/^\/+|\/+$/g, "");
+    if (!normalizedSegment) {
+        throw new Error(`${label} is required`);
+    }
+    if (normalizedSegment.includes("/")) {
+        throw new Error(`${label} must not contain slashes`);
+    }
+    return normalizedSegment;
+}
+function assertValidChunkSize(chunkSize) {
+    if (!Number.isFinite(chunkSize) || chunkSize <= 0) {
+        throw new Error("Multipart chunk size must be greater than zero");
+    }
+    if (chunkSize > MEDIA_CRATE_MULTIPART_MAX_CHUNK_BYTES) {
+        throw new Error(`Multipart chunk size must be <= ${MEDIA_CRATE_MULTIPART_MAX_CHUNK_BYTES} bytes`);
+    }
+}
+function getGlobalFetch() {
+    if (typeof fetch === "undefined") {
+        throw new Error("fetch is not defined. Please provide fetchImpl.");
+    }
+    return fetch;
+}
+function defaultSleep(durationMs) {
+    return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+function copySession(session) {
+    return {
+        ...session,
+        sections: [...session.sections],
+        startResult: session.startResult ? { ...session.startResult } : undefined,
+    };
+}
+function getSourceFingerprint(source) {
+    var _a, _b, _c;
+    return [
+        (_a = source.fingerprint) !== null && _a !== void 0 ? _a : "",
+        source.name,
+        source.size,
+        (_b = source.type) !== null && _b !== void 0 ? _b : "",
+        (_c = source.lastModified) !== null && _c !== void 0 ? _c : "",
+    ].join("|");
+}
+function createMultipartSessionKey(args) {
+    return [
+        args.baseUrl,
+        args.marketId,
+        args.mode,
+        args.path,
+        getSourceFingerprint(args.source),
+        args.chunkSize,
+        args.overwrite,
+    ].join("|");
+}
+function createPendingPartNumbers(totalParts, completedPartNumbers) {
+    const pending = [];
+    for (let partNumber = 1; partNumber <= totalParts; partNumber++) {
+        if (!completedPartNumbers.has(partNumber)) {
+            pending.push(partNumber);
+        }
+    }
+    return pending;
+}
+function getPartSize(args) {
+    const start = args.chunkSize * (args.partNumber - 1);
+    const end = Math.min(args.sourceSize, start + args.chunkSize);
+    return Math.max(0, end - start);
+}
+function getCompletedBytes(args) {
+    let bytes = 0;
+    for (let partNumber of args.completedPartNumbers) {
+        bytes += getPartSize({
+            partNumber,
+            sourceSize: args.sourceSize,
+            chunkSize: args.chunkSize,
+        });
+    }
+    return bytes;
+}
+function sortSections(sections) {
+    return [...sections].sort((a, b) => Number(a.partNumber) - Number(b.partNumber));
+}
+function appendUploadPart(formData, fieldName, partBody, fileName, mimeType) {
+    if (isReactNativeFormDataFile(partBody)) {
+        formData.append(fieldName, partBody);
+        return;
+    }
+    if (typeof Blob !== "undefined" && partBody instanceof Blob) {
+        formData.append(fieldName, partBody, fileName);
+        return;
+    }
+    if (partBody instanceof ArrayBuffer || partBody instanceof Uint8Array) {
+        formData.append(fieldName, new Blob([partBody], {
+            type: mimeType !== null && mimeType !== void 0 ? mimeType : "application/octet-stream",
+        }), fileName);
+        return;
+    }
+    formData.append(fieldName, partBody);
+}
+function isReactNativeFormDataFile(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !(typeof Blob !== "undefined" && value instanceof Blob) &&
+        !(value instanceof ArrayBuffer) &&
+        !(value instanceof Uint8Array) &&
+        typeof value.uri === "string");
+}
+function getMediaCrateUrls(source) {
+    if ("expected" in source) {
+        return source.expected;
+    }
+    if ("urls" in source) {
+        return source.urls;
+    }
+    return source;
+}
+function getMultipartUploadId(response) {
+    if ("uploadId" in response && typeof response.uploadId === "string") {
+        return response.uploadId;
+    }
+    if ("data" in response &&
+        response.data &&
+        typeof response.data.uploadId === "string") {
+        return response.data.uploadId;
+    }
+    return undefined;
+}
+function getMultipartTargetKey(response) {
+    if ("targetKey" in response && typeof response.targetKey === "string") {
+        return response.targetKey;
+    }
+    if ("data" in response &&
+        response.data &&
+        typeof response.data.key === "string") {
+        return response.data.key;
+    }
+    return undefined;
+}
+function getMultipartPartEtag(response) {
+    if ("data" in response) {
+        return response.data.eTag;
+    }
+    return response.eTag;
+}
+function getMultipartPartNumber(response) {
+    if ("data" in response) {
+        return response.data.partNumber;
+    }
+    return response.partNumber;
+}
+function hasUploadResultShape(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const maybeUploadResult = value;
+    return (typeof maybeUploadResult.assetId === "string" &&
+        typeof maybeUploadResult.statusUrl === "string" &&
+        typeof maybeUploadResult.status === "string" &&
+        typeof maybeUploadResult.expected === "object" &&
+        maybeUploadResult.expected !== null);
+}
+async function throwIfNotOk(response, method, url) {
+    if (response.ok) {
+        return;
+    }
+    const responseText = await response.text().catch(() => "");
+    let body = responseText || null;
+    if (responseText) {
+        try {
+            body = JSON.parse(responseText);
+        }
+        catch (_error) {
+            body = responseText;
+        }
+    }
+    const message = typeof body === "object" && body !== null && "message" in body
+        ? String(body.message)
+        : responseText || response.statusText || `Media Crate request failed`;
+    const collidingKeys = typeof body === "object" &&
+        body !== null &&
+        Array.isArray(body.collidingKeys)
+        ? body.collidingKeys
+        : undefined;
+    throw new MediaCrateHttpError({
+        status: response.status,
+        method,
+        url,
+        message,
+        body,
+        collidingKeys,
+    });
+}
+function isRetryableError(error) {
+    if (error instanceof MediaCrateHttpError) {
+        return error.status === 429 || error.status >= 500;
+    }
+    return true;
+}
+function shouldForgetMultipartSession(error) {
+    return (error instanceof MediaCrateHttpError &&
+        (error.status === 404 || error.status === 409));
+}
+
 class EarTag {
     static get countryCodesByNumber() {
         let reversed = {};
@@ -6811,11 +7222,26 @@ function incrementAlphaSequence(alpha) {
 
 exports.CattlePassport = CattlePassport;
 exports.EarTag = EarTag;
+exports.InMemoryMediaCrateMultipartSessionStore = InMemoryMediaCrateMultipartSessionStore;
+exports.MEDIA_CRATE_ASSET_STATUSES = MEDIA_CRATE_ASSET_STATUSES;
+exports.MEDIA_CRATE_DEFAULT_CHUNK_BYTES = MEDIA_CRATE_DEFAULT_CHUNK_BYTES;
+exports.MEDIA_CRATE_MEDIA_STATUSES = MEDIA_CRATE_MEDIA_STATUSES;
+exports.MEDIA_CRATE_MULTIPART_MAX_CHUNK_BYTES = MEDIA_CRATE_MULTIPART_MAX_CHUNK_BYTES;
+exports.MEDIA_CRATE_SINGLE_UPLOAD_MAX_BYTES = MEDIA_CRATE_SINGLE_UPLOAD_MAX_BYTES;
+exports.MEDIA_CRATE_V2_BASE_URL_ENV_VARS = MEDIA_CRATE_V2_BASE_URL_ENV_VARS;
+exports.MediaCrateClient = MediaCrateClient;
+exports.MediaCrateHttpError = MediaCrateHttpError;
+exports.MediaCrateUploadSourceError = MediaCrateUploadSourceError;
 exports.Studio = Studio;
 exports.StudioHeaders = StudioHeaders;
 exports.StudioTypes = types;
 exports.createAppManifest = createAppManifest;
+exports.createWebUploadSource = createWebUploadSource;
 exports.default = Studio;
+exports.getMediaCrateBaseUrlFromEnv = getMediaCrateBaseUrlFromEnv;
+exports.getMediaCrateVariant = getMediaCrateVariant;
+exports.getMediaCrateVariantUrl = getMediaCrateVariantUrl;
 exports.lotComparator = lotComparator;
 exports.nextLotNumber = nextLotNumber;
+exports.requireMediaCrateVariantUrl = requireMediaCrateVariantUrl;
 exports.sortByLotNumber = sortByLotNumber;