@deenruv/inpost-plugin 1.0.0

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

@@ -0,0 +1,1086 @@
+/* eslint-disable */
+import { AllTypesProps, ReturnTypes, Ops } from './const.js';
+export const HOST = "http://localhost:3000/admin-api";
+export const HEADERS = {};
+export const apiSubscription = (options) => (query) => {
+    try {
+        const queryString = options[0] + '?query=' + encodeURIComponent(query);
+        const wsString = queryString.replace('http', 'ws');
+        const host = (options.length > 1 && options[1]?.websocket?.[0]) || wsString;
+        const webSocketOptions = options[1]?.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 {
+        throw new Error('No websockets implemented');
+    }
+};
+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();
+};
+export 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]}`, {
+        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;
+    });
+};
+export const InternalsBuildQuery = ({ ops, props, returns, options, scalars, }) => {
+    const ibb = (k, o, p = '', root = true, vars = []) => {
+        const keyForPath = purifyGraphQLKey(k);
+        const newPath = [p, keyForPath].join(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 = 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?.operationName ? ' ' + options.operationName : '';
+        const keyForDirectives = o.__directives ?? '';
+        const query = `{${Object.entries(o)
+            .filter(([k]) => k !== '__directives')
+            .map((e) => ibb(...e, [p, `field<>${keyForPath}`].join(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;
+};
+export const Thunder = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = {
+        ...thunderGraphQLOptions,
+        ...graphqlOptions,
+    };
+    return fn(Zeus(operation, o, {
+        operationOptions: ops,
+        scalars: options?.scalars,
+    }), ops?.variables).then((data) => {
+        if (options?.scalars) {
+            return decodeScalarsInResponse({
+                response: data,
+                initialOp: operation,
+                initialZeusQuery: o,
+                returns: ReturnTypes,
+                scalars: options.scalars,
+                ops: Ops,
+            });
+        }
+        return data;
+    });
+};
+export const Chain = (...options) => Thunder(apiFetch(options));
+export const SubscriptionThunder = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = {
+        ...thunderGraphQLOptions,
+        ...graphqlOptions,
+    };
+    const returnedFunction = fn(Zeus(operation, o, {
+        operationOptions: ops,
+        scalars: options?.scalars,
+    }));
+    if (returnedFunction?.on && options?.scalars) {
+        const wrapped = returnedFunction.on;
+        returnedFunction.on = (fnToCall) => wrapped((data) => {
+            if (options?.scalars) {
+                return fnToCall(decodeScalarsInResponse({
+                    response: data,
+                    initialOp: operation,
+                    initialZeusQuery: o,
+                    returns: ReturnTypes,
+                    scalars: options.scalars,
+                    ops: Ops,
+                }));
+            }
+            return fnToCall(data);
+        });
+    }
+    return returnedFunction;
+};
+export const Subscription = (...options) => SubscriptionThunder(apiSubscription(options));
+export const Zeus = (operation, o, ops) => InternalsBuildQuery({
+    props: AllTypesProps,
+    returns: ReturnTypes,
+    ops: Ops,
+    options: ops?.operationOptions,
+    scalars: ops?.scalars,
+})(operation, o);
+export const ZeusSelect = () => ((t) => t);
+export const Selector = (key) => key && ZeusSelect();
+export const TypeFromSelector = (key) => key && ZeusSelect();
+export const Gql = Chain(HOST, {
+    headers: {
+        'Content-Type': 'application/json',
+        ...HEADERS,
+    },
+});
+export const ZeusScalars = ZeusSelect();
+export const fields = (k) => {
+    const t = ReturnTypes[k];
+    const fnType = k in AllTypesProps ? 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 = 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;
+};
+export const decodeScalarsInResponse = ({ response, scalars, returns, ops, initialZeusQuery, initialOp, }) => {
+    if (!scalars) {
+        return response;
+    }
+    const builder = PrepareScalarPaths({
+        ops,
+        returns,
+    });
+    const scalarPaths = builder(initialOp, ops[initialOp], initialZeusQuery);
+    if (scalarPaths) {
+        const r = traverseResponse({ scalarPaths, resolvers: scalars })(initialOp, response, [ops[initialOp]]);
+        return r;
+    }
+    return response;
+};
+export const traverseResponse = ({ resolvers, scalarPaths, }) => {
+    const ibb = (k, o, p = []) => {
+        if (Array.isArray(o)) {
+            return o.map((eachO) => ibb(k, eachO, p));
+        }
+        if (o == null) {
+            return o;
+        }
+        const scalarPathString = p.join(SEPARATOR);
+        const currentScalarString = scalarPaths[scalarPathString];
+        if (currentScalarString) {
+            const currentDecoder = resolvers[currentScalarString.split('.')[1]]?.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, purifyGraphQLKey(k)])]);
+        const objectFromEntries = entries.reduce((a, [k, v]) => {
+            a[k] = v;
+            return a;
+        }, {});
+        return objectFromEntries;
+    };
+    return ibb;
+};
+export const SEPARATOR = '|';
+export class GraphQLError extends Error {
+    constructor(response) {
+        super('');
+        this.response = response;
+        console.error(response);
+    }
+    toString() {
+        return 'GraphQL Response Error';
+    }
+}
+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;
+};
+export 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?.startsWith('scalar')) {
+                const partOfTree = {
+                    [[...p, k].join(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) => ({
+                ...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, purifyGraphQLKey(keyName || k)], isInlineFragment ? pOriginals : [...pOriginals, purifyGraphQLKey(originalKey)], false);
+        })
+            .reduce((a, b) => ({
+            ...a,
+            ...b,
+        }));
+    };
+    return ibb;
+};
+export const purifyGraphQLKey = (k) => k.replace(/\([^)]*\)/g, '').replace(/^[^:]*\:/g, '');
+const mapPart = (p) => {
+    const [isArg, isField] = p.split('<>');
+    if (isField) {
+        return {
+            v: isField,
+            __type: 'field',
+        };
+    }
+    return {
+        v: isArg,
+        __type: 'arg',
+    };
+};
+export 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}${SEPARATOR}${mappedParts
+                    .slice(2)
+                    .map((mp) => mp.v)
+                    .join(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}${SEPARATOR}${mappedParts
+                        .slice(3)
+                        .map((mp) => mp.v)
+                        .join(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}${SEPARATOR}${mappedParts
+                    .slice(2)
+                    .map((mp) => mp.v)
+                    .join(SEPARATOR)}`);
+            }
+        }
+    };
+    const rpp = (path) => {
+        const parts = path.split(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;
+};
+export const InternalArgsBuilt = ({ props, ops, returns, scalars, vars, }) => {
+    const arb = (a, p = '', root = true) => {
+        if (typeof a === 'string') {
+            if (a.startsWith(START_VAR_NAME)) {
+                const [varName, graphQLType] = a.replace(START_VAR_NAME, '$').split(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 = 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 scalars?.[scalarKey]?.encode?.(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(SEPARATOR), false)}`)
+                .join(',\n');
+            if (!root) {
+                return `{${returnedObjectString}}`;
+            }
+            return returnedObjectString;
+        }
+        return `${a}`;
+    };
+    return arb;
+};
+export const resolverFor = (type, field, fn) => fn;
+export const START_VAR_NAME = `$ZEUS_VAR`;
+export const GRAPHQL_TYPE_SEPARATOR = `__$GRAPHQL__`;
+export const $ = (name, graphqlType) => {
+    return (START_VAR_NAME + name + GRAPHQL_TYPE_SEPARATOR + graphqlType);
+};
+/** @description
+The state of a Job in the JobQueue
+
+@docsCategory common */
+export var JobState;
+(function (JobState) {
+    JobState["PENDING"] = "PENDING";
+    JobState["RUNNING"] = "RUNNING";
+    JobState["COMPLETED"] = "COMPLETED";
+    JobState["RETRYING"] = "RETRYING";
+    JobState["FAILED"] = "FAILED";
+    JobState["CANCELLED"] = "CANCELLED";
+})(JobState || (JobState = {}));
+export var StockMovementType;
+(function (StockMovementType) {
+    StockMovementType["ADJUSTMENT"] = "ADJUSTMENT";
+    StockMovementType["ALLOCATION"] = "ALLOCATION";
+    StockMovementType["RELEASE"] = "RELEASE";
+    StockMovementType["SALE"] = "SALE";
+    StockMovementType["CANCELLATION"] = "CANCELLATION";
+    StockMovementType["RETURN"] = "RETURN";
+})(StockMovementType || (StockMovementType = {}));
+export var AssetType;
+(function (AssetType) {
+    AssetType["IMAGE"] = "IMAGE";
+    AssetType["VIDEO"] = "VIDEO";
+    AssetType["BINARY"] = "BINARY";
+})(AssetType || (AssetType = {}));
+export var GlobalFlag;
+(function (GlobalFlag) {
+    GlobalFlag["TRUE"] = "TRUE";
+    GlobalFlag["FALSE"] = "FALSE";
+    GlobalFlag["INHERIT"] = "INHERIT";
+})(GlobalFlag || (GlobalFlag = {}));
+export var AdjustmentType;
+(function (AdjustmentType) {
+    AdjustmentType["PROMOTION"] = "PROMOTION";
+    AdjustmentType["DISTRIBUTED_ORDER_PROMOTION"] = "DISTRIBUTED_ORDER_PROMOTION";
+    AdjustmentType["OTHER"] = "OTHER";
+})(AdjustmentType || (AdjustmentType = {}));
+export var DeletionResult;
+(function (DeletionResult) {
+    DeletionResult["DELETED"] = "DELETED";
+    DeletionResult["NOT_DELETED"] = "NOT_DELETED";
+})(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 */
+export 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 || (Permission = {}));
+export var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASC"] = "ASC";
+    SortOrder["DESC"] = "DESC";
+})(SortOrder || (SortOrder = {}));
+export 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 || (ErrorCode = {}));
+export var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["AND"] = "AND";
+    LogicalOperator["OR"] = "OR";
+})(LogicalOperator || (LogicalOperator = {}));
+/** @description
+ISO 4217 currency code
+
+@docsCategory common */
+export 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 || (CurrencyCode = {}));
+export 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 || (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 */
+export 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 || (LanguageCode = {}));
+export var OrderType;
+(function (OrderType) {
+    OrderType["Regular"] = "Regular";
+    OrderType["Seller"] = "Seller";
+    OrderType["Aggregate"] = "Aggregate";
+})(OrderType || (OrderType = {}));
+export var MetricInterval;
+(function (MetricInterval) {
+    MetricInterval["Daily"] = "Daily";
+})(MetricInterval || (MetricInterval = {}));
+export var MetricType;
+(function (MetricType) {
+    MetricType["OrderCount"] = "OrderCount";
+    MetricType["OrderTotal"] = "OrderTotal";
+    MetricType["AverageOrderValue"] = "AverageOrderValue";
+})(MetricType || (MetricType = {}));