@deenruv/product-options-fields-plugin 1.0.17-dev.20 → 1.0.17-dev.23

package/dist/plugin-server/zeus/index.js

@@ -0,0 +1,1276 @@
+"use strict";
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricType = exports.MetricInterval = exports.ChartMetricType = exports.MetricIntervalType = exports.MetricRangeType = exports.OrderType = exports.LanguageCode = exports.HistoryEntryType = exports.CurrencyCode = exports.LogicalOperator = exports.ErrorCode = exports.SortOrder = exports.Permission = exports.DeletionResult = exports.AdjustmentType = exports.GlobalFlag = exports.AssetType = exports.StockMovementType = exports.JobState = exports.$ = exports.GRAPHQL_TYPE_SEPARATOR = exports.START_VAR_NAME = exports.resolverFor = exports.InternalArgsBuilt = exports.ResolveFromPath = exports.purifyGraphQLKey = exports.PrepareScalarPaths = exports.GraphQLError = exports.SEPARATOR = exports.traverseResponse = exports.decodeScalarsInResponse = exports.fields = exports.ZeusScalars = exports.Gql = exports.TypeFromSelector = exports.Selector = exports.ZeusSelect = exports.Zeus = exports.SubscriptionSSE = exports.SubscriptionThunderSSE = exports.Subscription = exports.SubscriptionThunder = exports.Chain = exports.Thunder = exports.InternalsBuildQuery = exports.apiFetch = exports.apiSubscriptionSSE = exports.apiSubscription = exports.HEADERS = exports.HOST = void 0;
+const const_1 = require("./const");
+exports.HOST = "http://localhost:6100/admin-api";
+exports.HEADERS = {};
+const apiSubscription = (options) => (query) => {
+    var _a, _b, _c;
+    try {
+        const queryString = options[0] + "?query=" + encodeURIComponent(query);
+        const wsString = queryString.replace("http", "ws");
+        const host = (options.length > 1 && ((_b = (_a = options[1]) === null || _a === void 0 ? void 0 : _a.websocket) === null || _b === void 0 ? void 0 : _b[0])) || wsString;
+        const webSocketOptions = ((_c = options[1]) === null || _c === void 0 ? void 0 : _c.websocket) || [host];
+        const ws = new WebSocket(...webSocketOptions);
+        return {
+            ws,
+            on: (e) => {
+                ws.onmessage = (event) => {
+                    if (event.data) {
+                        const parsed = JSON.parse(event.data);
+                        const data = parsed.data;
+                        return e(data);
+                    }
+                };
+            },
+            off: (e) => {
+                ws.onclose = e;
+            },
+            error: (e) => {
+                ws.onerror = e;
+            },
+            open: (e) => {
+                ws.onopen = e;
+            },
+        };
+    }
+    catch (_d) {
+        throw new Error("No websockets implemented");
+    }
+};
+exports.apiSubscription = apiSubscription;
+const apiSubscriptionSSE = (options) => (query, variables) => {
+    const url = options[0];
+    const fetchOptions = options[1] || {};
+    let abortController = null;
+    let reader = null;
+    let onCallback = null;
+    let errorCallback = null;
+    let openCallback = null;
+    let offCallback = null;
+    let isClosing = false; // Flag to track intentional close
+    const startStream = async () => {
+        var _a;
+        try {
+            abortController = new AbortController();
+            const response = await fetch(url, Object.assign({ method: "POST", headers: Object.assign({ Accept: "text/event-stream", "Content-Type": "application/json", "Cache-Control": "no-cache" }, fetchOptions.headers), body: JSON.stringify({ query, variables }), signal: abortController.signal }, fetchOptions));
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            if (openCallback) {
+                openCallback();
+            }
+            reader = ((_a = response.body) === null || _a === void 0 ? void 0 : _a.getReader()) || null;
+            if (!reader) {
+                throw new Error("No response body");
+            }
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    if (offCallback) {
+                        offCallback({
+                            data: null,
+                            code: 1000,
+                            reason: "Stream completed",
+                        });
+                    }
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        try {
+                            const data = line.slice(6);
+                            const parsed = JSON.parse(data);
+                            if (parsed.errors) {
+                                if (errorCallback) {
+                                    errorCallback({ data: parsed.data, errors: parsed.errors });
+                                }
+                            }
+                            else if (onCallback && parsed.data) {
+                                onCallback(parsed.data);
+                            }
+                        }
+                        catch (_b) {
+                            if (errorCallback) {
+                                errorCallback({ errors: ["Failed to parse SSE data"] });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const error = err;
+            // Don't report errors if we're intentionally closing (AbortError) or during cleanup
+            if (error.name !== "AbortError" && !isClosing && errorCallback) {
+                errorCallback({ errors: [error.message || "Unknown error"] });
+            }
+        }
+    };
+    return {
+        on: (e) => {
+            onCallback = e;
+        },
+        off: (e) => {
+            offCallback = e;
+        },
+        error: (e) => {
+            errorCallback = e;
+        },
+        open: (e) => {
+            if (e) {
+                openCallback = e;
+            }
+            startStream();
+        },
+        close: () => {
+            isClosing = true; // Mark as intentionally closing to suppress error callbacks
+            if (abortController) {
+                abortController.abort();
+            }
+            if (reader) {
+                // Wrap in try-catch to suppress AbortError during cleanup
+                reader.cancel().catch(() => {
+                    // Ignore cancel errors - stream may already be closed
+                });
+            }
+        },
+    };
+};
+exports.apiSubscriptionSSE = apiSubscriptionSSE;
+const handleFetchResponse = (response) => {
+    if (!response.ok) {
+        return new Promise((_, reject) => {
+            response
+                .text()
+                .then((text) => {
+                try {
+                    reject(JSON.parse(text));
+                }
+                catch (err) {
+                    reject(text);
+                }
+            })
+                .catch(reject);
+        });
+    }
+    return response.json();
+};
+const apiFetch = (options) => (query, variables = {}) => {
+    const fetchOptions = options[1] || {};
+    if (fetchOptions.method && fetchOptions.method === "GET") {
+        return fetch(`${options[0]}?query=${encodeURIComponent(query)}`, fetchOptions)
+            .then(handleFetchResponse)
+            .then((response) => {
+            if (response.errors) {
+                throw new GraphQLError(response);
+            }
+            return response.data;
+        });
+    }
+    return fetch(`${options[0]}`, Object.assign({ body: JSON.stringify({ query, variables }), method: "POST", headers: {
+            "Content-Type": "application/json",
+        } }, fetchOptions))
+        .then(handleFetchResponse)
+        .then((response) => {
+        if (response.errors) {
+            throw new GraphQLError(response);
+        }
+        return response.data;
+    });
+};
+exports.apiFetch = apiFetch;
+const InternalsBuildQuery = ({ ops, props, returns, options, scalars, }) => {
+    const ibb = (k, o, p = "", root = true, vars = []) => {
+        var _a;
+        const keyForPath = (0, exports.purifyGraphQLKey)(k);
+        const newPath = [p, keyForPath].join(exports.SEPARATOR);
+        if (!o) {
+            return "";
+        }
+        if (typeof o === "boolean" || typeof o === "number") {
+            return k;
+        }
+        if (typeof o === "string") {
+            return `${k} ${o}`;
+        }
+        if (Array.isArray(o)) {
+            const args = (0, exports.InternalArgsBuilt)({
+                props,
+                returns,
+                ops,
+                scalars,
+                vars,
+            })(o[0], newPath);
+            return `${ibb(args ? `${k}(${args})` : k, o[1], p, false, vars)}`;
+        }
+        if (k === "__alias") {
+            return Object.entries(o)
+                .map(([alias, objectUnderAlias]) => {
+                if (typeof objectUnderAlias !== "object" ||
+                    Array.isArray(objectUnderAlias)) {
+                    throw new Error("Invalid alias it should be __alias:{ YOUR_ALIAS_NAME: { OPERATION_NAME: { ...selectors }}}");
+                }
+                const operationName = Object.keys(objectUnderAlias)[0];
+                const operation = objectUnderAlias[operationName];
+                return ibb(`${alias}:${operationName}`, operation, p, false, vars);
+            })
+                .join("\n");
+        }
+        const hasOperationName = root && (options === null || options === void 0 ? void 0 : options.operationName) ? " " + options.operationName : "";
+        const keyForDirectives = (_a = o.__directives) !== null && _a !== void 0 ? _a : "";
+        const query = `{${Object.entries(o)
+            .filter(([k]) => k !== "__directives")
+            .map((e) => ibb(...e, [p, `field<>${keyForPath}`].join(exports.SEPARATOR), false, vars))
+            .join("\n")}}`;
+        if (!root) {
+            return `${k} ${keyForDirectives}${hasOperationName} ${query}`;
+        }
+        const varsString = vars
+            .map((v) => `${v.name}: ${v.graphQLType}`)
+            .join(", ");
+        return `${k} ${keyForDirectives}${hasOperationName}${varsString ? `(${varsString})` : ""} ${query}`;
+    };
+    return ibb;
+};
+exports.InternalsBuildQuery = InternalsBuildQuery;
+const Thunder = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = Object.assign(Object.assign({}, thunderGraphQLOptions), graphqlOptions);
+    return fn((0, exports.Zeus)(operation, o, {
+        operationOptions: ops,
+        scalars: options === null || options === void 0 ? void 0 : options.scalars,
+    }), ops === null || ops === void 0 ? void 0 : ops.variables).then((data) => {
+        if (options === null || options === void 0 ? void 0 : options.scalars) {
+            return (0, exports.decodeScalarsInResponse)({
+                response: data,
+                initialOp: operation,
+                initialZeusQuery: o,
+                returns: const_1.ReturnTypes,
+                scalars: options.scalars,
+                ops: const_1.Ops,
+            });
+        }
+        return data;
+    });
+};
+exports.Thunder = Thunder;
+const Chain = (...options) => (0, exports.Thunder)((0, exports.apiFetch)(options));
+exports.Chain = Chain;
+const SubscriptionThunder = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = Object.assign(Object.assign({}, thunderGraphQLOptions), graphqlOptions);
+    const returnedFunction = fn((0, exports.Zeus)(operation, o, {
+        operationOptions: ops,
+        scalars: options === null || options === void 0 ? void 0 : options.scalars,
+    }));
+    if ((returnedFunction === null || returnedFunction === void 0 ? void 0 : returnedFunction.on) && (options === null || options === void 0 ? void 0 : options.scalars)) {
+        const wrapped = returnedFunction.on;
+        returnedFunction.on = (fnToCall) => wrapped((data) => {
+            if (options === null || options === void 0 ? void 0 : options.scalars) {
+                return fnToCall((0, exports.decodeScalarsInResponse)({
+                    response: data,
+                    initialOp: operation,
+                    initialZeusQuery: o,
+                    returns: const_1.ReturnTypes,
+                    scalars: options.scalars,
+                    ops: const_1.Ops,
+                }));
+            }
+            return fnToCall(data);
+        });
+    }
+    return returnedFunction;
+};
+exports.SubscriptionThunder = SubscriptionThunder;
+const Subscription = (...options) => (0, exports.SubscriptionThunder)((0, exports.apiSubscription)(options));
+exports.Subscription = Subscription;
+const SubscriptionThunderSSE = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = Object.assign(Object.assign({}, thunderGraphQLOptions), graphqlOptions);
+    const returnedFunction = fn((0, exports.Zeus)(operation, o, {
+        operationOptions: ops,
+        scalars: options === null || options === void 0 ? void 0 : options.scalars,
+    }), ops === null || ops === void 0 ? void 0 : ops.variables);
+    if ((returnedFunction === null || returnedFunction === void 0 ? void 0 : returnedFunction.on) && (options === null || options === void 0 ? void 0 : options.scalars)) {
+        const wrapped = returnedFunction.on;
+        returnedFunction.on = (fnToCall) => wrapped((data) => {
+            if (options === null || options === void 0 ? void 0 : options.scalars) {
+                return fnToCall((0, exports.decodeScalarsInResponse)({
+                    response: data,
+                    initialOp: operation,
+                    initialZeusQuery: o,
+                    returns: const_1.ReturnTypes,
+                    scalars: options.scalars,
+                    ops: const_1.Ops,
+                }));
+            }
+            return fnToCall(data);
+        });
+    }
+    return returnedFunction;
+};
+exports.SubscriptionThunderSSE = SubscriptionThunderSSE;
+const SubscriptionSSE = (...options) => (0, exports.SubscriptionThunderSSE)((0, exports.apiSubscriptionSSE)(options));
+exports.SubscriptionSSE = SubscriptionSSE;
+const Zeus = (operation, o, ops) => (0, exports.InternalsBuildQuery)({
+    props: const_1.AllTypesProps,
+    returns: const_1.ReturnTypes,
+    ops: const_1.Ops,
+    options: ops === null || ops === void 0 ? void 0 : ops.operationOptions,
+    scalars: ops === null || ops === void 0 ? void 0 : ops.scalars,
+})(operation, o);
+exports.Zeus = Zeus;
+const ZeusSelect = () => ((t) => t);
+exports.ZeusSelect = ZeusSelect;
+const Selector = (key) => key && (0, exports.ZeusSelect)();
+exports.Selector = Selector;
+const TypeFromSelector = (key) => key && (0, exports.ZeusSelect)();
+exports.TypeFromSelector = TypeFromSelector;
+exports.Gql = (0, exports.Chain)(exports.HOST, {
+    headers: Object.assign({ "Content-Type": "application/json" }, exports.HEADERS),
+});
+exports.ZeusScalars = (0, exports.ZeusSelect)();
+const fields = (k) => {
+    const t = const_1.ReturnTypes[k];
+    const fnType = k in const_1.AllTypesProps
+        ? const_1.AllTypesProps[k]
+        : undefined;
+    const hasFnTypes = typeof fnType === "object" ? fnType : undefined;
+    const o = Object.fromEntries(Object.entries(t)
+        .filter(([k, value]) => {
+        const isFunctionType = hasFnTypes &&
+            k in hasFnTypes &&
+            !!hasFnTypes[k];
+        if (isFunctionType)
+            return false;
+        const isReturnType = const_1.ReturnTypes[value];
+        if (!isReturnType)
+            return true;
+        if (typeof isReturnType !== "string")
+            return false;
+        if (isReturnType.startsWith("scalar.")) {
+            return true;
+        }
+        return false;
+    })
+        .map(([key]) => [key, true]));
+    return o;
+};
+exports.fields = fields;
+const decodeScalarsInResponse = ({ response, scalars, returns, ops, initialZeusQuery, initialOp, }) => {
+    if (!scalars) {
+        return response;
+    }
+    const builder = (0, exports.PrepareScalarPaths)({
+        ops,
+        returns,
+    });
+    const scalarPaths = builder(initialOp, ops[initialOp], initialZeusQuery);
+    if (scalarPaths) {
+        const r = (0, exports.traverseResponse)({ scalarPaths, resolvers: scalars })(initialOp, response, [ops[initialOp]]);
+        return r;
+    }
+    return response;
+};
+exports.decodeScalarsInResponse = decodeScalarsInResponse;
+const traverseResponse = ({ resolvers, scalarPaths, }) => {
+    const ibb = (k, o, p = []) => {
+        var _a;
+        if (Array.isArray(o)) {
+            return o.map((eachO) => ibb(k, eachO, p));
+        }
+        if (o == null) {
+            return o;
+        }
+        const scalarPathString = p.join(exports.SEPARATOR);
+        const currentScalarString = scalarPaths[scalarPathString];
+        if (currentScalarString) {
+            const currentDecoder = (_a = resolvers[currentScalarString.split(".")[1]]) === null || _a === void 0 ? void 0 : _a.decode;
+            if (currentDecoder) {
+                return currentDecoder(o);
+            }
+        }
+        if (typeof o === "boolean" ||
+            typeof o === "number" ||
+            typeof o === "string" ||
+            !o) {
+            return o;
+        }
+        const entries = Object.entries(o).map(([k, v]) => [k, ibb(k, v, [...p, (0, exports.purifyGraphQLKey)(k)])]);
+        const objectFromEntries = entries.reduce((a, [k, v]) => {
+            a[k] = v;
+            return a;
+        }, {});
+        return objectFromEntries;
+    };
+    return ibb;
+};
+exports.traverseResponse = traverseResponse;
+exports.SEPARATOR = "|";
+class GraphQLError extends Error {
+    constructor(response) {
+        var _a, _b;
+        super(((_b = (_a = response.errors) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) || "GraphQL Response Error");
+        this.response = response;
+        console.error(response);
+    }
+    toString() {
+        return "GraphQL Response Error";
+    }
+}
+exports.GraphQLError = GraphQLError;
+const ExtractScalar = (mappedParts, returns) => {
+    if (mappedParts.length === 0) {
+        return;
+    }
+    const oKey = mappedParts[0];
+    const returnP1 = returns[oKey];
+    if (typeof returnP1 === "object") {
+        const returnP2 = returnP1[mappedParts[1]];
+        if (returnP2) {
+            return ExtractScalar([returnP2, ...mappedParts.slice(2)], returns);
+        }
+        return undefined;
+    }
+    return returnP1;
+};
+const PrepareScalarPaths = ({ ops, returns, }) => {
+    const ibb = (k, originalKey, o, p = [], pOriginals = [], root = true) => {
+        if (!o) {
+            return;
+        }
+        if (typeof o === "boolean" ||
+            typeof o === "number" ||
+            typeof o === "string") {
+            const extractionArray = [...pOriginals, originalKey];
+            const isScalar = ExtractScalar(extractionArray, returns);
+            if (isScalar === null || isScalar === void 0 ? void 0 : isScalar.startsWith("scalar")) {
+                const partOfTree = {
+                    [[...p, k].join(exports.SEPARATOR)]: isScalar,
+                };
+                return partOfTree;
+            }
+            return {};
+        }
+        if (Array.isArray(o)) {
+            return ibb(k, k, o[1], p, pOriginals, false);
+        }
+        if (k === "__alias") {
+            return Object.entries(o)
+                .map(([alias, objectUnderAlias]) => {
+                if (typeof objectUnderAlias !== "object" ||
+                    Array.isArray(objectUnderAlias)) {
+                    throw new Error("Invalid alias it should be __alias:{ YOUR_ALIAS_NAME: { OPERATION_NAME: { ...selectors }}}");
+                }
+                const operationName = Object.keys(objectUnderAlias)[0];
+                const operation = objectUnderAlias[operationName];
+                return ibb(alias, operationName, operation, p, pOriginals, false);
+            })
+                .reduce((a, b) => (Object.assign(Object.assign({}, a), b)));
+        }
+        const keyName = root ? ops[k] : k;
+        return Object.entries(o)
+            .filter(([k]) => k !== "__directives")
+            .map(([k, v]) => {
+            // Inline fragments shouldn't be added to the path as they aren't a field
+            const isInlineFragment = originalKey.match(/^...\s*on/) != null;
+            return ibb(k, k, v, isInlineFragment ? p : [...p, (0, exports.purifyGraphQLKey)(keyName || k)], isInlineFragment
+                ? pOriginals
+                : [...pOriginals, (0, exports.purifyGraphQLKey)(originalKey)], false);
+        })
+            .reduce((a, b) => (Object.assign(Object.assign({}, a), b)));
+    };
+    return ibb;
+};
+exports.PrepareScalarPaths = PrepareScalarPaths;
+const purifyGraphQLKey = (k) => k.replace(/\([^)]*\)/g, "").replace(/^[^:]*\:/g, "");
+exports.purifyGraphQLKey = purifyGraphQLKey;
+const mapPart = (p) => {
+    const [isArg, isField] = p.split("<>");
+    if (isField) {
+        return {
+            v: isField,
+            __type: "field",
+        };
+    }
+    return {
+        v: isArg,
+        __type: "arg",
+    };
+};
+const ResolveFromPath = (props, returns, ops) => {
+    const ResolvePropsType = (mappedParts) => {
+        const oKey = ops[mappedParts[0].v];
+        const propsP1 = oKey ? props[oKey] : props[mappedParts[0].v];
+        if (propsP1 === "enum" && mappedParts.length === 1) {
+            return "enum";
+        }
+        if (typeof propsP1 === "string" &&
+            propsP1.startsWith("scalar.") &&
+            mappedParts.length === 1) {
+            return propsP1;
+        }
+        if (typeof propsP1 === "object") {
+            if (mappedParts.length < 2) {
+                return "not";
+            }
+            const propsP2 = propsP1[mappedParts[1].v];
+            if (typeof propsP2 === "string") {
+                return rpp(`${propsP2}${exports.SEPARATOR}${mappedParts
+                    .slice(2)
+                    .map((mp) => mp.v)
+                    .join(exports.SEPARATOR)}`);
+            }
+            if (typeof propsP2 === "object") {
+                if (mappedParts.length < 3) {
+                    return "not";
+                }
+                const propsP3 = propsP2[mappedParts[2].v];
+                if (propsP3 && mappedParts[2].__type === "arg") {
+                    return rpp(`${propsP3}${exports.SEPARATOR}${mappedParts
+                        .slice(3)
+                        .map((mp) => mp.v)
+                        .join(exports.SEPARATOR)}`);
+                }
+            }
+        }
+    };
+    const ResolveReturnType = (mappedParts) => {
+        if (mappedParts.length === 0) {
+            return "not";
+        }
+        const oKey = ops[mappedParts[0].v];
+        const returnP1 = oKey ? returns[oKey] : returns[mappedParts[0].v];
+        if (typeof returnP1 === "object") {
+            if (mappedParts.length < 2)
+                return "not";
+            const returnP2 = returnP1[mappedParts[1].v];
+            if (returnP2) {
+                return rpp(`${returnP2}${exports.SEPARATOR}${mappedParts
+                    .slice(2)
+                    .map((mp) => mp.v)
+                    .join(exports.SEPARATOR)}`);
+            }
+        }
+    };
+    const rpp = (path) => {
+        const parts = path.split(exports.SEPARATOR).filter((l) => l.length > 0);
+        const mappedParts = parts.map(mapPart);
+        const propsP1 = ResolvePropsType(mappedParts);
+        if (propsP1) {
+            return propsP1;
+        }
+        const returnP1 = ResolveReturnType(mappedParts);
+        if (returnP1) {
+            return returnP1;
+        }
+        return "not";
+    };
+    return rpp;
+};
+exports.ResolveFromPath = ResolveFromPath;
+const InternalArgsBuilt = ({ props, ops, returns, scalars, vars, }) => {
+    const arb = (a, p = "", root = true) => {
+        var _a, _b;
+        if (typeof a === "string") {
+            if (a.startsWith(exports.START_VAR_NAME)) {
+                const [varName, graphQLType] = a
+                    .replace(exports.START_VAR_NAME, "$")
+                    .split(exports.GRAPHQL_TYPE_SEPARATOR);
+                const v = vars.find((v) => v.name === varName);
+                if (!v) {
+                    vars.push({
+                        name: varName,
+                        graphQLType,
+                    });
+                }
+                else {
+                    if (v.graphQLType !== graphQLType) {
+                        throw new Error(`Invalid variable exists with two different GraphQL Types, "${v.graphQLType}" and ${graphQLType}`);
+                    }
+                }
+                return varName;
+            }
+        }
+        const checkType = (0, exports.ResolveFromPath)(props, returns, ops)(p);
+        if (checkType.startsWith("scalar.")) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const [_, ...splittedScalar] = checkType.split(".");
+            const scalarKey = splittedScalar.join(".");
+            return ((_b = (_a = scalars === null || scalars === void 0 ? void 0 : scalars[scalarKey]) === null || _a === void 0 ? void 0 : _a.encode) === null || _b === void 0 ? void 0 : _b.call(_a, a)) || JSON.stringify(a);
+        }
+        if (Array.isArray(a)) {
+            return `[${a.map((arr) => arb(arr, p, false)).join(", ")}]`;
+        }
+        if (typeof a === "string") {
+            if (checkType === "enum") {
+                return a;
+            }
+            return `${JSON.stringify(a)}`;
+        }
+        if (typeof a === "object") {
+            if (a === null) {
+                return `null`;
+            }
+            const returnedObjectString = Object.entries(a)
+                .filter(([, v]) => typeof v !== "undefined")
+                .map(([k, v]) => `${k}: ${arb(v, [p, k].join(exports.SEPARATOR), false)}`)
+                .join(",\n");
+            if (!root) {
+                return `{${returnedObjectString}}`;
+            }
+            return returnedObjectString;
+        }
+        return `${a}`;
+    };
+    return arb;
+};
+exports.InternalArgsBuilt = InternalArgsBuilt;
+const resolverFor = (_type, _field, fn) => fn;
+exports.resolverFor = resolverFor;
+exports.START_VAR_NAME = `$ZEUS_VAR`;
+exports.GRAPHQL_TYPE_SEPARATOR = `__$GRAPHQL__`;
+const $ = (name, graphqlType) => {
+    return (exports.START_VAR_NAME +
+        name +
+        exports.GRAPHQL_TYPE_SEPARATOR +
+        graphqlType);
+};
+exports.$ = $;
+/** @description
+The state of a Job in the JobQueue
+
+@docsCategory common */
+var JobState;
+(function (JobState) {
+    JobState["PENDING"] = "PENDING";
+    JobState["RUNNING"] = "RUNNING";
+    JobState["COMPLETED"] = "COMPLETED";
+    JobState["RETRYING"] = "RETRYING";
+    JobState["FAILED"] = "FAILED";
+    JobState["CANCELLED"] = "CANCELLED";
+})(JobState || (exports.JobState = JobState = {}));
+var StockMovementType;
+(function (StockMovementType) {
+    StockMovementType["ADJUSTMENT"] = "ADJUSTMENT";
+    StockMovementType["ALLOCATION"] = "ALLOCATION";
+    StockMovementType["RELEASE"] = "RELEASE";
+    StockMovementType["SALE"] = "SALE";
+    StockMovementType["CANCELLATION"] = "CANCELLATION";
+    StockMovementType["RETURN"] = "RETURN";
+})(StockMovementType || (exports.StockMovementType = StockMovementType = {}));
+var AssetType;
+(function (AssetType) {
+    AssetType["IMAGE"] = "IMAGE";
+    AssetType["VIDEO"] = "VIDEO";
+    AssetType["BINARY"] = "BINARY";
+})(AssetType || (exports.AssetType = AssetType = {}));
+var GlobalFlag;
+(function (GlobalFlag) {
+    GlobalFlag["TRUE"] = "TRUE";
+    GlobalFlag["FALSE"] = "FALSE";
+    GlobalFlag["INHERIT"] = "INHERIT";
+})(GlobalFlag || (exports.GlobalFlag = GlobalFlag = {}));
+var AdjustmentType;
+(function (AdjustmentType) {
+    AdjustmentType["PROMOTION"] = "PROMOTION";
+    AdjustmentType["DISTRIBUTED_ORDER_PROMOTION"] = "DISTRIBUTED_ORDER_PROMOTION";
+    AdjustmentType["OTHER"] = "OTHER";
+})(AdjustmentType || (exports.AdjustmentType = AdjustmentType = {}));
+var DeletionResult;
+(function (DeletionResult) {
+    DeletionResult["DELETED"] = "DELETED";
+    DeletionResult["NOT_DELETED"] = "NOT_DELETED";
+})(DeletionResult || (exports.DeletionResult = DeletionResult = {}));
+/** @description
+Permissions for administrators and customers. Used to control access to
+GraphQL resolvers via the {@link Allow} decorator.
+
+## Understanding Permission.Owner
+
+`Permission.Owner` is a special permission which is used in some Deenruv resolvers to indicate that that resolver should only
+be accessible to the "owner" of that resource.
+
+For example, the Shop API `activeCustomer` query resolver should only return the Customer object for the "owner" of that Customer, i.e.
+based on the activeUserId of the current session. As a result, the resolver code looks like this:
+
+@example
+```TypeScript
+\@Query()
+\@Allow(Permission.Owner)
+async activeCustomer(\@Ctx() ctx: RequestContext): Promise<Customer | undefined> {
+  const userId = ctx.activeUserId;
+  if (userId) {
+    return this.customerService.findOneByUserId(ctx, userId);
+  }
+}
+```
+
+Here we can see that the "ownership" must be enforced by custom logic inside the resolver. Since "ownership" cannot be defined generally
+nor statically encoded at build-time, any resolvers using `Permission.Owner` **must** include logic to enforce that only the owner
+of the resource has access. If not, then it is the equivalent of using `Permission.Public`.
+
+
+@docsCategory common */
+var Permission;
+(function (Permission) {
+    Permission["Authenticated"] = "Authenticated";
+    Permission["SuperAdmin"] = "SuperAdmin";
+    Permission["Owner"] = "Owner";
+    Permission["Public"] = "Public";
+    Permission["UpdateGlobalSettings"] = "UpdateGlobalSettings";
+    Permission["CreateCatalog"] = "CreateCatalog";
+    Permission["ReadCatalog"] = "ReadCatalog";
+    Permission["UpdateCatalog"] = "UpdateCatalog";
+    Permission["DeleteCatalog"] = "DeleteCatalog";
+    Permission["CreateSettings"] = "CreateSettings";
+    Permission["ReadSettings"] = "ReadSettings";
+    Permission["UpdateSettings"] = "UpdateSettings";
+    Permission["DeleteSettings"] = "DeleteSettings";
+    Permission["CreateAdministrator"] = "CreateAdministrator";
+    Permission["ReadAdministrator"] = "ReadAdministrator";
+    Permission["UpdateAdministrator"] = "UpdateAdministrator";
+    Permission["DeleteAdministrator"] = "DeleteAdministrator";
+    Permission["CreateAsset"] = "CreateAsset";
+    Permission["ReadAsset"] = "ReadAsset";
+    Permission["UpdateAsset"] = "UpdateAsset";
+    Permission["DeleteAsset"] = "DeleteAsset";
+    Permission["CreateChannel"] = "CreateChannel";
+    Permission["ReadChannel"] = "ReadChannel";
+    Permission["UpdateChannel"] = "UpdateChannel";
+    Permission["DeleteChannel"] = "DeleteChannel";
+    Permission["CreateCollection"] = "CreateCollection";
+    Permission["ReadCollection"] = "ReadCollection";
+    Permission["UpdateCollection"] = "UpdateCollection";
+    Permission["DeleteCollection"] = "DeleteCollection";
+    Permission["CreateCountry"] = "CreateCountry";
+    Permission["ReadCountry"] = "ReadCountry";
+    Permission["UpdateCountry"] = "UpdateCountry";
+    Permission["DeleteCountry"] = "DeleteCountry";
+    Permission["CreateCustomer"] = "CreateCustomer";
+    Permission["ReadCustomer"] = "ReadCustomer";
+    Permission["UpdateCustomer"] = "UpdateCustomer";
+    Permission["DeleteCustomer"] = "DeleteCustomer";
+    Permission["CreateCustomerGroup"] = "CreateCustomerGroup";
+    Permission["ReadCustomerGroup"] = "ReadCustomerGroup";
+    Permission["UpdateCustomerGroup"] = "UpdateCustomerGroup";
+    Permission["DeleteCustomerGroup"] = "DeleteCustomerGroup";
+    Permission["CreateFacet"] = "CreateFacet";
+    Permission["ReadFacet"] = "ReadFacet";
+    Permission["UpdateFacet"] = "UpdateFacet";
+    Permission["DeleteFacet"] = "DeleteFacet";
+    Permission["CreateOrder"] = "CreateOrder";
+    Permission["ReadOrder"] = "ReadOrder";
+    Permission["UpdateOrder"] = "UpdateOrder";
+    Permission["DeleteOrder"] = "DeleteOrder";
+    Permission["CreatePaymentMethod"] = "CreatePaymentMethod";
+    Permission["ReadPaymentMethod"] = "ReadPaymentMethod";
+    Permission["UpdatePaymentMethod"] = "UpdatePaymentMethod";
+    Permission["DeletePaymentMethod"] = "DeletePaymentMethod";
+    Permission["CreateProduct"] = "CreateProduct";
+    Permission["ReadProduct"] = "ReadProduct";
+    Permission["UpdateProduct"] = "UpdateProduct";
+    Permission["DeleteProduct"] = "DeleteProduct";
+    Permission["CreatePromotion"] = "CreatePromotion";
+    Permission["ReadPromotion"] = "ReadPromotion";
+    Permission["UpdatePromotion"] = "UpdatePromotion";
+    Permission["DeletePromotion"] = "DeletePromotion";
+    Permission["CreateShippingMethod"] = "CreateShippingMethod";
+    Permission["ReadShippingMethod"] = "ReadShippingMethod";
+    Permission["UpdateShippingMethod"] = "UpdateShippingMethod";
+    Permission["DeleteShippingMethod"] = "DeleteShippingMethod";
+    Permission["CreateTag"] = "CreateTag";
+    Permission["ReadTag"] = "ReadTag";
+    Permission["UpdateTag"] = "UpdateTag";
+    Permission["DeleteTag"] = "DeleteTag";
+    Permission["CreateTaxCategory"] = "CreateTaxCategory";
+    Permission["ReadTaxCategory"] = "ReadTaxCategory";
+    Permission["UpdateTaxCategory"] = "UpdateTaxCategory";
+    Permission["DeleteTaxCategory"] = "DeleteTaxCategory";
+    Permission["CreateTaxRate"] = "CreateTaxRate";
+    Permission["ReadTaxRate"] = "ReadTaxRate";
+    Permission["UpdateTaxRate"] = "UpdateTaxRate";
+    Permission["DeleteTaxRate"] = "DeleteTaxRate";
+    Permission["CreateSeller"] = "CreateSeller";
+    Permission["ReadSeller"] = "ReadSeller";
+    Permission["UpdateSeller"] = "UpdateSeller";
+    Permission["DeleteSeller"] = "DeleteSeller";
+    Permission["CreateStockLocation"] = "CreateStockLocation";
+    Permission["ReadStockLocation"] = "ReadStockLocation";
+    Permission["UpdateStockLocation"] = "UpdateStockLocation";
+    Permission["DeleteStockLocation"] = "DeleteStockLocation";
+    Permission["CreateSystem"] = "CreateSystem";
+    Permission["ReadSystem"] = "ReadSystem";
+    Permission["UpdateSystem"] = "UpdateSystem";
+    Permission["DeleteSystem"] = "DeleteSystem";
+    Permission["CreateZone"] = "CreateZone";
+    Permission["ReadZone"] = "ReadZone";
+    Permission["UpdateZone"] = "UpdateZone";
+    Permission["DeleteZone"] = "DeleteZone";
+})(Permission || (exports.Permission = Permission = {}));
+var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASC"] = "ASC";
+    SortOrder["DESC"] = "DESC";
+})(SortOrder || (exports.SortOrder = SortOrder = {}));
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+    ErrorCode["MIME_TYPE_ERROR"] = "MIME_TYPE_ERROR";
+    ErrorCode["LANGUAGE_NOT_AVAILABLE_ERROR"] = "LANGUAGE_NOT_AVAILABLE_ERROR";
+    ErrorCode["DUPLICATE_ENTITY_ERROR"] = "DUPLICATE_ENTITY_ERROR";
+    ErrorCode["FACET_IN_USE_ERROR"] = "FACET_IN_USE_ERROR";
+    ErrorCode["CHANNEL_DEFAULT_LANGUAGE_ERROR"] = "CHANNEL_DEFAULT_LANGUAGE_ERROR";
+    ErrorCode["SETTLE_PAYMENT_ERROR"] = "SETTLE_PAYMENT_ERROR";
+    ErrorCode["CANCEL_PAYMENT_ERROR"] = "CANCEL_PAYMENT_ERROR";
+    ErrorCode["EMPTY_ORDER_LINE_SELECTION_ERROR"] = "EMPTY_ORDER_LINE_SELECTION_ERROR";
+    ErrorCode["ITEMS_ALREADY_FULFILLED_ERROR"] = "ITEMS_ALREADY_FULFILLED_ERROR";
+    ErrorCode["INVALID_FULFILLMENT_HANDLER_ERROR"] = "INVALID_FULFILLMENT_HANDLER_ERROR";
+    ErrorCode["CREATE_FULFILLMENT_ERROR"] = "CREATE_FULFILLMENT_ERROR";
+    ErrorCode["INSUFFICIENT_STOCK_ON_HAND_ERROR"] = "INSUFFICIENT_STOCK_ON_HAND_ERROR";
+    ErrorCode["MULTIPLE_ORDER_ERROR"] = "MULTIPLE_ORDER_ERROR";
+    ErrorCode["CANCEL_ACTIVE_ORDER_ERROR"] = "CANCEL_ACTIVE_ORDER_ERROR";
+    ErrorCode["PAYMENT_ORDER_MISMATCH_ERROR"] = "PAYMENT_ORDER_MISMATCH_ERROR";
+    ErrorCode["REFUND_ORDER_STATE_ERROR"] = "REFUND_ORDER_STATE_ERROR";
+    ErrorCode["NOTHING_TO_REFUND_ERROR"] = "NOTHING_TO_REFUND_ERROR";
+    ErrorCode["ALREADY_REFUNDED_ERROR"] = "ALREADY_REFUNDED_ERROR";
+    ErrorCode["QUANTITY_TOO_GREAT_ERROR"] = "QUANTITY_TOO_GREAT_ERROR";
+    ErrorCode["REFUND_AMOUNT_ERROR"] = "REFUND_AMOUNT_ERROR";
+    ErrorCode["REFUND_STATE_TRANSITION_ERROR"] = "REFUND_STATE_TRANSITION_ERROR";
+    ErrorCode["PAYMENT_STATE_TRANSITION_ERROR"] = "PAYMENT_STATE_TRANSITION_ERROR";
+    ErrorCode["FULFILLMENT_STATE_TRANSITION_ERROR"] = "FULFILLMENT_STATE_TRANSITION_ERROR";
+    ErrorCode["ORDER_MODIFICATION_STATE_ERROR"] = "ORDER_MODIFICATION_STATE_ERROR";
+    ErrorCode["NO_CHANGES_SPECIFIED_ERROR"] = "NO_CHANGES_SPECIFIED_ERROR";
+    ErrorCode["PAYMENT_METHOD_MISSING_ERROR"] = "PAYMENT_METHOD_MISSING_ERROR";
+    ErrorCode["REFUND_PAYMENT_ID_MISSING_ERROR"] = "REFUND_PAYMENT_ID_MISSING_ERROR";
+    ErrorCode["MANUAL_PAYMENT_STATE_ERROR"] = "MANUAL_PAYMENT_STATE_ERROR";
+    ErrorCode["PRODUCT_OPTION_IN_USE_ERROR"] = "PRODUCT_OPTION_IN_USE_ERROR";
+    ErrorCode["MISSING_CONDITIONS_ERROR"] = "MISSING_CONDITIONS_ERROR";
+    ErrorCode["NATIVE_AUTH_STRATEGY_ERROR"] = "NATIVE_AUTH_STRATEGY_ERROR";
+    ErrorCode["INVALID_CREDENTIALS_ERROR"] = "INVALID_CREDENTIALS_ERROR";
+    ErrorCode["ORDER_STATE_TRANSITION_ERROR"] = "ORDER_STATE_TRANSITION_ERROR";
+    ErrorCode["EMAIL_ADDRESS_CONFLICT_ERROR"] = "EMAIL_ADDRESS_CONFLICT_ERROR";
+    ErrorCode["GUEST_CHECKOUT_ERROR"] = "GUEST_CHECKOUT_ERROR";
+    ErrorCode["ORDER_LIMIT_ERROR"] = "ORDER_LIMIT_ERROR";
+    ErrorCode["NEGATIVE_QUANTITY_ERROR"] = "NEGATIVE_QUANTITY_ERROR";
+    ErrorCode["INSUFFICIENT_STOCK_ERROR"] = "INSUFFICIENT_STOCK_ERROR";
+    ErrorCode["COUPON_CODE_INVALID_ERROR"] = "COUPON_CODE_INVALID_ERROR";
+    ErrorCode["COUPON_CODE_EXPIRED_ERROR"] = "COUPON_CODE_EXPIRED_ERROR";
+    ErrorCode["COUPON_CODE_LIMIT_ERROR"] = "COUPON_CODE_LIMIT_ERROR";
+    ErrorCode["ORDER_MODIFICATION_ERROR"] = "ORDER_MODIFICATION_ERROR";
+    ErrorCode["INELIGIBLE_SHIPPING_METHOD_ERROR"] = "INELIGIBLE_SHIPPING_METHOD_ERROR";
+    ErrorCode["NO_ACTIVE_ORDER_ERROR"] = "NO_ACTIVE_ORDER_ERROR";
+    ErrorCode["ORDER_MIDDLEWARE_ERROR"] = "ORDER_MIDDLEWARE_ERROR";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["AND"] = "AND";
+    LogicalOperator["OR"] = "OR";
+})(LogicalOperator || (exports.LogicalOperator = LogicalOperator = {}));
+/** @description
+ISO 4217 currency code
+
+@docsCategory common */
+var CurrencyCode;
+(function (CurrencyCode) {
+    CurrencyCode["AED"] = "AED";
+    CurrencyCode["AFN"] = "AFN";
+    CurrencyCode["ALL"] = "ALL";
+    CurrencyCode["AMD"] = "AMD";
+    CurrencyCode["ANG"] = "ANG";
+    CurrencyCode["AOA"] = "AOA";
+    CurrencyCode["ARS"] = "ARS";
+    CurrencyCode["AUD"] = "AUD";
+    CurrencyCode["AWG"] = "AWG";
+    CurrencyCode["AZN"] = "AZN";
+    CurrencyCode["BAM"] = "BAM";
+    CurrencyCode["BBD"] = "BBD";
+    CurrencyCode["BDT"] = "BDT";
+    CurrencyCode["BGN"] = "BGN";
+    CurrencyCode["BHD"] = "BHD";
+    CurrencyCode["BIF"] = "BIF";
+    CurrencyCode["BMD"] = "BMD";
+    CurrencyCode["BND"] = "BND";
+    CurrencyCode["BOB"] = "BOB";
+    CurrencyCode["BRL"] = "BRL";
+    CurrencyCode["BSD"] = "BSD";
+    CurrencyCode["BTN"] = "BTN";
+    CurrencyCode["BWP"] = "BWP";
+    CurrencyCode["BYN"] = "BYN";
+    CurrencyCode["BZD"] = "BZD";
+    CurrencyCode["CAD"] = "CAD";
+    CurrencyCode["CDF"] = "CDF";
+    CurrencyCode["CHF"] = "CHF";
+    CurrencyCode["CLP"] = "CLP";
+    CurrencyCode["CNY"] = "CNY";
+    CurrencyCode["COP"] = "COP";
+    CurrencyCode["CRC"] = "CRC";
+    CurrencyCode["CUC"] = "CUC";
+    CurrencyCode["CUP"] = "CUP";
+    CurrencyCode["CVE"] = "CVE";
+    CurrencyCode["CZK"] = "CZK";
+    CurrencyCode["DJF"] = "DJF";
+    CurrencyCode["DKK"] = "DKK";
+    CurrencyCode["DOP"] = "DOP";
+    CurrencyCode["DZD"] = "DZD";
+    CurrencyCode["EGP"] = "EGP";
+    CurrencyCode["ERN"] = "ERN";
+    CurrencyCode["ETB"] = "ETB";
+    CurrencyCode["EUR"] = "EUR";
+    CurrencyCode["FJD"] = "FJD";
+    CurrencyCode["FKP"] = "FKP";
+    CurrencyCode["GBP"] = "GBP";
+    CurrencyCode["GEL"] = "GEL";
+    CurrencyCode["GHS"] = "GHS";
+    CurrencyCode["GIP"] = "GIP";
+    CurrencyCode["GMD"] = "GMD";
+    CurrencyCode["GNF"] = "GNF";
+    CurrencyCode["GTQ"] = "GTQ";
+    CurrencyCode["GYD"] = "GYD";
+    CurrencyCode["HKD"] = "HKD";
+    CurrencyCode["HNL"] = "HNL";
+    CurrencyCode["HRK"] = "HRK";
+    CurrencyCode["HTG"] = "HTG";
+    CurrencyCode["HUF"] = "HUF";
+    CurrencyCode["IDR"] = "IDR";
+    CurrencyCode["ILS"] = "ILS";
+    CurrencyCode["INR"] = "INR";
+    CurrencyCode["IQD"] = "IQD";
+    CurrencyCode["IRR"] = "IRR";
+    CurrencyCode["ISK"] = "ISK";
+    CurrencyCode["JMD"] = "JMD";
+    CurrencyCode["JOD"] = "JOD";
+    CurrencyCode["JPY"] = "JPY";
+    CurrencyCode["KES"] = "KES";
+    CurrencyCode["KGS"] = "KGS";
+    CurrencyCode["KHR"] = "KHR";
+    CurrencyCode["KMF"] = "KMF";
+    CurrencyCode["KPW"] = "KPW";
+    CurrencyCode["KRW"] = "KRW";
+    CurrencyCode["KWD"] = "KWD";
+    CurrencyCode["KYD"] = "KYD";
+    CurrencyCode["KZT"] = "KZT";
+    CurrencyCode["LAK"] = "LAK";
+    CurrencyCode["LBP"] = "LBP";
+    CurrencyCode["LKR"] = "LKR";
+    CurrencyCode["LRD"] = "LRD";
+    CurrencyCode["LSL"] = "LSL";
+    CurrencyCode["LYD"] = "LYD";
+    CurrencyCode["MAD"] = "MAD";
+    CurrencyCode["MDL"] = "MDL";
+    CurrencyCode["MGA"] = "MGA";
+    CurrencyCode["MKD"] = "MKD";
+    CurrencyCode["MMK"] = "MMK";
+    CurrencyCode["MNT"] = "MNT";
+    CurrencyCode["MOP"] = "MOP";
+    CurrencyCode["MRU"] = "MRU";
+    CurrencyCode["MUR"] = "MUR";
+    CurrencyCode["MVR"] = "MVR";
+    CurrencyCode["MWK"] = "MWK";
+    CurrencyCode["MXN"] = "MXN";
+    CurrencyCode["MYR"] = "MYR";
+    CurrencyCode["MZN"] = "MZN";
+    CurrencyCode["NAD"] = "NAD";
+    CurrencyCode["NGN"] = "NGN";
+    CurrencyCode["NIO"] = "NIO";
+    CurrencyCode["NOK"] = "NOK";
+    CurrencyCode["NPR"] = "NPR";
+    CurrencyCode["NZD"] = "NZD";
+    CurrencyCode["OMR"] = "OMR";
+    CurrencyCode["PAB"] = "PAB";
+    CurrencyCode["PEN"] = "PEN";
+    CurrencyCode["PGK"] = "PGK";
+    CurrencyCode["PHP"] = "PHP";
+    CurrencyCode["PKR"] = "PKR";
+    CurrencyCode["PLN"] = "PLN";
+    CurrencyCode["PYG"] = "PYG";
+    CurrencyCode["QAR"] = "QAR";
+    CurrencyCode["RON"] = "RON";
+    CurrencyCode["RSD"] = "RSD";
+    CurrencyCode["RUB"] = "RUB";
+    CurrencyCode["RWF"] = "RWF";
+    CurrencyCode["SAR"] = "SAR";
+    CurrencyCode["SBD"] = "SBD";
+    CurrencyCode["SCR"] = "SCR";
+    CurrencyCode["SDG"] = "SDG";
+    CurrencyCode["SEK"] = "SEK";
+    CurrencyCode["SGD"] = "SGD";
+    CurrencyCode["SHP"] = "SHP";
+    CurrencyCode["SLL"] = "SLL";
+    CurrencyCode["SOS"] = "SOS";
+    CurrencyCode["SRD"] = "SRD";
+    CurrencyCode["SSP"] = "SSP";
+    CurrencyCode["STN"] = "STN";
+    CurrencyCode["SVC"] = "SVC";
+    CurrencyCode["SYP"] = "SYP";
+    CurrencyCode["SZL"] = "SZL";
+    CurrencyCode["THB"] = "THB";
+    CurrencyCode["TJS"] = "TJS";
+    CurrencyCode["TMT"] = "TMT";
+    CurrencyCode["TND"] = "TND";
+    CurrencyCode["TOP"] = "TOP";
+    CurrencyCode["TRY"] = "TRY";
+    CurrencyCode["TTD"] = "TTD";
+    CurrencyCode["TWD"] = "TWD";
+    CurrencyCode["TZS"] = "TZS";
+    CurrencyCode["UAH"] = "UAH";
+    CurrencyCode["UGX"] = "UGX";
+    CurrencyCode["USD"] = "USD";
+    CurrencyCode["UYU"] = "UYU";
+    CurrencyCode["UZS"] = "UZS";
+    CurrencyCode["VES"] = "VES";
+    CurrencyCode["VND"] = "VND";
+    CurrencyCode["VUV"] = "VUV";
+    CurrencyCode["WST"] = "WST";
+    CurrencyCode["XAF"] = "XAF";
+    CurrencyCode["XCD"] = "XCD";
+    CurrencyCode["XOF"] = "XOF";
+    CurrencyCode["XPF"] = "XPF";
+    CurrencyCode["YER"] = "YER";
+    CurrencyCode["ZAR"] = "ZAR";
+    CurrencyCode["ZMW"] = "ZMW";
+    CurrencyCode["ZWL"] = "ZWL";
+})(CurrencyCode || (exports.CurrencyCode = CurrencyCode = {}));
+var HistoryEntryType;
+(function (HistoryEntryType) {
+    HistoryEntryType["CUSTOMER_REGISTERED"] = "CUSTOMER_REGISTERED";
+    HistoryEntryType["CUSTOMER_VERIFIED"] = "CUSTOMER_VERIFIED";
+    HistoryEntryType["CUSTOMER_DETAIL_UPDATED"] = "CUSTOMER_DETAIL_UPDATED";
+    HistoryEntryType["CUSTOMER_ADDED_TO_GROUP"] = "CUSTOMER_ADDED_TO_GROUP";
+    HistoryEntryType["CUSTOMER_REMOVED_FROM_GROUP"] = "CUSTOMER_REMOVED_FROM_GROUP";
+    HistoryEntryType["CUSTOMER_ADDRESS_CREATED"] = "CUSTOMER_ADDRESS_CREATED";
+    HistoryEntryType["CUSTOMER_ADDRESS_UPDATED"] = "CUSTOMER_ADDRESS_UPDATED";
+    HistoryEntryType["CUSTOMER_ADDRESS_DELETED"] = "CUSTOMER_ADDRESS_DELETED";
+    HistoryEntryType["CUSTOMER_PASSWORD_UPDATED"] = "CUSTOMER_PASSWORD_UPDATED";
+    HistoryEntryType["CUSTOMER_PASSWORD_RESET_REQUESTED"] = "CUSTOMER_PASSWORD_RESET_REQUESTED";
+    HistoryEntryType["CUSTOMER_PASSWORD_RESET_VERIFIED"] = "CUSTOMER_PASSWORD_RESET_VERIFIED";
+    HistoryEntryType["CUSTOMER_EMAIL_UPDATE_REQUESTED"] = "CUSTOMER_EMAIL_UPDATE_REQUESTED";
+    HistoryEntryType["CUSTOMER_EMAIL_UPDATE_VERIFIED"] = "CUSTOMER_EMAIL_UPDATE_VERIFIED";
+    HistoryEntryType["CUSTOMER_NOTE"] = "CUSTOMER_NOTE";
+    HistoryEntryType["ORDER_STATE_TRANSITION"] = "ORDER_STATE_TRANSITION";
+    HistoryEntryType["ORDER_PAYMENT_TRANSITION"] = "ORDER_PAYMENT_TRANSITION";
+    HistoryEntryType["ORDER_FULFILLMENT"] = "ORDER_FULFILLMENT";
+    HistoryEntryType["ORDER_CANCELLATION"] = "ORDER_CANCELLATION";
+    HistoryEntryType["ORDER_REFUND_TRANSITION"] = "ORDER_REFUND_TRANSITION";
+    HistoryEntryType["ORDER_FULFILLMENT_TRANSITION"] = "ORDER_FULFILLMENT_TRANSITION";
+    HistoryEntryType["ORDER_NOTE"] = "ORDER_NOTE";
+    HistoryEntryType["ORDER_COUPON_APPLIED"] = "ORDER_COUPON_APPLIED";
+    HistoryEntryType["ORDER_COUPON_REMOVED"] = "ORDER_COUPON_REMOVED";
+    HistoryEntryType["ORDER_MODIFIED"] = "ORDER_MODIFIED";
+    HistoryEntryType["ORDER_CUSTOMER_UPDATED"] = "ORDER_CUSTOMER_UPDATED";
+})(HistoryEntryType || (exports.HistoryEntryType = HistoryEntryType = {}));
+/** @description
+Languages in the form of a ISO 639-1 language code with optional
+region or script modifier (e.g. de_AT). The selection available is based
+on the [Unicode CLDR summary list](https://unicode-org.github.io/cldr-staging/charts/37/summary/root.html)
+and includes the major spoken languages of the world and any widely-used variants.
+
+@docsCategory common */
+var LanguageCode;
+(function (LanguageCode) {
+    LanguageCode["af"] = "af";
+    LanguageCode["ak"] = "ak";
+    LanguageCode["sq"] = "sq";
+    LanguageCode["am"] = "am";
+    LanguageCode["ar"] = "ar";
+    LanguageCode["hy"] = "hy";
+    LanguageCode["as"] = "as";
+    LanguageCode["az"] = "az";
+    LanguageCode["bm"] = "bm";
+    LanguageCode["bn"] = "bn";
+    LanguageCode["eu"] = "eu";
+    LanguageCode["be"] = "be";
+    LanguageCode["bs"] = "bs";
+    LanguageCode["br"] = "br";
+    LanguageCode["bg"] = "bg";
+    LanguageCode["my"] = "my";
+    LanguageCode["ca"] = "ca";
+    LanguageCode["ce"] = "ce";
+    LanguageCode["zh"] = "zh";
+    LanguageCode["zh_Hans"] = "zh_Hans";
+    LanguageCode["zh_Hant"] = "zh_Hant";
+    LanguageCode["cu"] = "cu";
+    LanguageCode["kw"] = "kw";
+    LanguageCode["co"] = "co";
+    LanguageCode["hr"] = "hr";
+    LanguageCode["cs"] = "cs";
+    LanguageCode["da"] = "da";
+    LanguageCode["nl"] = "nl";
+    LanguageCode["nl_BE"] = "nl_BE";
+    LanguageCode["dz"] = "dz";
+    LanguageCode["en"] = "en";
+    LanguageCode["en_AU"] = "en_AU";
+    LanguageCode["en_CA"] = "en_CA";
+    LanguageCode["en_GB"] = "en_GB";
+    LanguageCode["en_US"] = "en_US";
+    LanguageCode["eo"] = "eo";
+    LanguageCode["et"] = "et";
+    LanguageCode["ee"] = "ee";
+    LanguageCode["fo"] = "fo";
+    LanguageCode["fi"] = "fi";
+    LanguageCode["fr"] = "fr";
+    LanguageCode["fr_CA"] = "fr_CA";
+    LanguageCode["fr_CH"] = "fr_CH";
+    LanguageCode["ff"] = "ff";
+    LanguageCode["gl"] = "gl";
+    LanguageCode["lg"] = "lg";
+    LanguageCode["ka"] = "ka";
+    LanguageCode["de"] = "de";
+    LanguageCode["de_AT"] = "de_AT";
+    LanguageCode["de_CH"] = "de_CH";
+    LanguageCode["el"] = "el";
+    LanguageCode["gu"] = "gu";
+    LanguageCode["ht"] = "ht";
+    LanguageCode["ha"] = "ha";
+    LanguageCode["he"] = "he";
+    LanguageCode["hi"] = "hi";
+    LanguageCode["hu"] = "hu";
+    LanguageCode["is"] = "is";
+    LanguageCode["ig"] = "ig";
+    LanguageCode["id"] = "id";
+    LanguageCode["ia"] = "ia";
+    LanguageCode["ga"] = "ga";
+    LanguageCode["it"] = "it";
+    LanguageCode["ja"] = "ja";
+    LanguageCode["jv"] = "jv";
+    LanguageCode["kl"] = "kl";
+    LanguageCode["kn"] = "kn";
+    LanguageCode["ks"] = "ks";
+    LanguageCode["kk"] = "kk";
+    LanguageCode["km"] = "km";
+    LanguageCode["ki"] = "ki";
+    LanguageCode["rw"] = "rw";
+    LanguageCode["ko"] = "ko";
+    LanguageCode["ku"] = "ku";
+    LanguageCode["ky"] = "ky";
+    LanguageCode["lo"] = "lo";
+    LanguageCode["la"] = "la";
+    LanguageCode["lv"] = "lv";
+    LanguageCode["ln"] = "ln";
+    LanguageCode["lt"] = "lt";
+    LanguageCode["lu"] = "lu";
+    LanguageCode["lb"] = "lb";
+    LanguageCode["mk"] = "mk";
+    LanguageCode["mg"] = "mg";
+    LanguageCode["ms"] = "ms";
+    LanguageCode["ml"] = "ml";
+    LanguageCode["mt"] = "mt";
+    LanguageCode["gv"] = "gv";
+    LanguageCode["mi"] = "mi";
+    LanguageCode["mr"] = "mr";
+    LanguageCode["mn"] = "mn";
+    LanguageCode["ne"] = "ne";
+    LanguageCode["nd"] = "nd";
+    LanguageCode["se"] = "se";
+    LanguageCode["nb"] = "nb";
+    LanguageCode["nn"] = "nn";
+    LanguageCode["ny"] = "ny";
+    LanguageCode["or"] = "or";
+    LanguageCode["om"] = "om";
+    LanguageCode["os"] = "os";
+    LanguageCode["ps"] = "ps";
+    LanguageCode["fa"] = "fa";
+    LanguageCode["fa_AF"] = "fa_AF";
+    LanguageCode["pl"] = "pl";
+    LanguageCode["pt"] = "pt";
+    LanguageCode["pt_BR"] = "pt_BR";
+    LanguageCode["pt_PT"] = "pt_PT";
+    LanguageCode["pa"] = "pa";
+    LanguageCode["qu"] = "qu";
+    LanguageCode["ro"] = "ro";
+    LanguageCode["ro_MD"] = "ro_MD";
+    LanguageCode["rm"] = "rm";
+    LanguageCode["rn"] = "rn";
+    LanguageCode["ru"] = "ru";
+    LanguageCode["sm"] = "sm";
+    LanguageCode["sg"] = "sg";
+    LanguageCode["sa"] = "sa";
+    LanguageCode["gd"] = "gd";
+    LanguageCode["sr"] = "sr";
+    LanguageCode["sn"] = "sn";
+    LanguageCode["ii"] = "ii";
+    LanguageCode["sd"] = "sd";
+    LanguageCode["si"] = "si";
+    LanguageCode["sk"] = "sk";
+    LanguageCode["sl"] = "sl";
+    LanguageCode["so"] = "so";
+    LanguageCode["st"] = "st";
+    LanguageCode["es"] = "es";
+    LanguageCode["es_ES"] = "es_ES";
+    LanguageCode["es_MX"] = "es_MX";
+    LanguageCode["su"] = "su";
+    LanguageCode["sw"] = "sw";
+    LanguageCode["sw_CD"] = "sw_CD";
+    LanguageCode["sv"] = "sv";
+    LanguageCode["tg"] = "tg";
+    LanguageCode["ta"] = "ta";
+    LanguageCode["tt"] = "tt";
+    LanguageCode["te"] = "te";
+    LanguageCode["th"] = "th";
+    LanguageCode["bo"] = "bo";
+    LanguageCode["ti"] = "ti";
+    LanguageCode["to"] = "to";
+    LanguageCode["tr"] = "tr";
+    LanguageCode["tk"] = "tk";
+    LanguageCode["uk"] = "uk";
+    LanguageCode["ur"] = "ur";
+    LanguageCode["ug"] = "ug";
+    LanguageCode["uz"] = "uz";
+    LanguageCode["vi"] = "vi";
+    LanguageCode["vo"] = "vo";
+    LanguageCode["cy"] = "cy";
+    LanguageCode["fy"] = "fy";
+    LanguageCode["wo"] = "wo";
+    LanguageCode["xh"] = "xh";
+    LanguageCode["yi"] = "yi";
+    LanguageCode["yo"] = "yo";
+    LanguageCode["zu"] = "zu";
+})(LanguageCode || (exports.LanguageCode = LanguageCode = {}));
+var OrderType;
+(function (OrderType) {
+    OrderType["Regular"] = "Regular";
+    OrderType["Seller"] = "Seller";
+    OrderType["Aggregate"] = "Aggregate";
+})(OrderType || (exports.OrderType = OrderType = {}));
+var MetricRangeType;
+(function (MetricRangeType) {
+    MetricRangeType["Today"] = "Today";
+    MetricRangeType["Yesterday"] = "Yesterday";
+    MetricRangeType["ThisWeek"] = "ThisWeek";
+    MetricRangeType["LastWeek"] = "LastWeek";
+    MetricRangeType["ThisMonth"] = "ThisMonth";
+    MetricRangeType["LastMonth"] = "LastMonth";
+    MetricRangeType["ThisYear"] = "ThisYear";
+    MetricRangeType["LastYear"] = "LastYear";
+    MetricRangeType["FirstQuarter"] = "FirstQuarter";
+    MetricRangeType["SecondQuarter"] = "SecondQuarter";
+    MetricRangeType["ThirdQuarter"] = "ThirdQuarter";
+    MetricRangeType["FourthQuarter"] = "FourthQuarter";
+    MetricRangeType["Custom"] = "Custom";
+})(MetricRangeType || (exports.MetricRangeType = MetricRangeType = {}));
+var MetricIntervalType;
+(function (MetricIntervalType) {
+    MetricIntervalType["Day"] = "Day";
+    MetricIntervalType["Hour"] = "Hour";
+})(MetricIntervalType || (exports.MetricIntervalType = MetricIntervalType = {}));
+var ChartMetricType;
+(function (ChartMetricType) {
+    ChartMetricType["OrderCount"] = "OrderCount";
+    ChartMetricType["OrderTotal"] = "OrderTotal";
+    ChartMetricType["AverageOrderValue"] = "AverageOrderValue";
+    ChartMetricType["OrderTotalProductsCount"] = "OrderTotalProductsCount";
+})(ChartMetricType || (exports.ChartMetricType = ChartMetricType = {}));
+var MetricInterval;
+(function (MetricInterval) {
+    MetricInterval["Daily"] = "Daily";
+})(MetricInterval || (exports.MetricInterval = MetricInterval = {}));
+var MetricType;
+(function (MetricType) {
+    MetricType["OrderCount"] = "OrderCount";
+    MetricType["OrderTotal"] = "OrderTotal";
+    MetricType["AverageOrderValue"] = "AverageOrderValue";
+})(MetricType || (exports.MetricType = MetricType = {}));