@configura/web-api 1.6.0-iotest.2 → 1.6.0-rc.0

package/dist/tests/testData/testDataUpcharge.js

@@ -1,151 +1,119 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { CfgProduct } from "../../CfgProduct.js";
-import { Collector } from "./collectorForTest.js";
-import { dummyCatId } from "./dummyProductForTest.js";
-const Prd = () => ({
-    uuid: "Prd",
-    unit: "m",
-    features: [
-        {
-            code: "NoUpcharge",
-            description: "",
-            numericOrder: false,
-            options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 0,
-                },
-            ],
-        },
-        {
-            code: "WithUpcharge",
-            description: "",
-            numericOrder: false,
-            options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 10,
-                },
-            ],
-        },
-        {
-            code: "WithUpchargeSelectMany",
-            description: "",
-            numericOrder: false,
-            optional: true,
-            options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 10,
-                },
-            ],
-        },
-    ],
-    productData: {
-        sku: "Prd",
-        partsData: {
-            basePrice: 40,
-            currency: "EURO",
-            listPrice: 50,
-            pkgCount: 0,
-            styleNr: "",
-            selOptions: [
-                {
-                    code: "!~!",
-                    next: {
-                        A: {
-                            code: "A",
-                        },
-                    },
-                },
-                {
-                    code: "!~!",
-                    next: {
-                        A: {
-                            code: "A",
-                        },
-                    },
-                },
-                {
-                    code: "!~!",
-                    next: {
-                        A: {
-                            code: "A",
-                        },
-                    },
-                },
-            ],
-        },
-    },
-    rootFeatureRefs: [
-        { code: "NoUpcharge" },
-        { code: "WithUpcharge" },
-        { code: "WithUpchargeSelectMany" },
-    ],
-});
-const getProduct = (params) => __awaiter(void 0, void 0, void 0, function* () { return Prd(); });
-export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0, function* () {
-    const productLoader = {
-        getProduct,
-        postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
-            const productData = (yield getProduct(params)).productData;
-            const validateResponse = {
-                uuid: "",
-                validated: true,
-                productData,
-            };
-            return validateResponse;
-        }),
-    };
-    const product = yield CfgProduct.make(productLoader, "lang", dummyCatId, "Table");
-    const collect = new Collector(product);
-    const beforeSnapshot = collect.takeSnapshot();
-    yield testFunc(product);
-    const afterSnapshot = collect.takeSnapshot();
-    const diff = collect.compareSnapshot(beforeSnapshot, afterSnapshot);
-    const notifications = collect.notifications;
-    return {
-        beforeSnapshot: Collector.stripRefsForWrapper(beforeSnapshot),
-        afterSnapshot: Collector.stripRefsForWrapper(afterSnapshot),
-        diff,
-        notifications,
-    };
-});
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { CfgProduct } from "../../CfgProduct.js";
+import { Collector } from "./collectorForTest.js";
+import { dummyCatId } from "./dummyProductForTest.js";
+import { letterOptionCodeA, letterOptions } from "./testDataOptions.js";
+const Prd = () => ({
+    uuid: "Prd",
+    unit: "m",
+    features: [
+        {
+            code: "NoUpcharge",
+            description: "",
+            numericOrder: false,
+            options: [
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 0 }),
+            ],
+        },
+        {
+            code: "WithUpcharge",
+            description: "",
+            numericOrder: false,
+            options: [
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
+            ],
+        },
+        {
+            code: "WithUpchargeSelectMany",
+            description: "",
+            numericOrder: false,
+            optional: true,
+            options: [
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
+            ],
+        },
+    ],
+    productData: {
+        sku: "Prd",
+        partsData: {
+            basePrice: 40,
+            currency: "EURO",
+            listPrice: 50,
+            pkgCount: 0,
+            styleNr: "",
+            selOptions: [
+                {
+                    code: "!~!",
+                    next: {
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
+                        },
+                    },
+                },
+                {
+                    code: "!~!",
+                    next: {
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
+                        },
+                    },
+                },
+                {
+                    code: "!~!",
+                    next: {
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
+                        },
+                    },
+                },
+            ],
+        },
+    },
+    rootFeatureRefs: [
+        { code: "NoUpcharge" },
+        { code: "WithUpcharge" },
+        { code: "WithUpchargeSelectMany" },
+    ],
+});
+const getProduct = (params) => Promise.resolve(Prd());
+export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0, function* () {
+    const productLoader = {
+        getProduct,
+        postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
+            const productData = (yield getProduct(params)).productData;
+            const validateResponse = {
+                uuid: "",
+                validated: true,
+                productData,
+            };
+            return validateResponse;
+        }),
+    };
+    const product = yield CfgProduct.make(productLoader, "lang", dummyCatId, "Table");
+    const collect = new Collector(product);
+    const beforeSnapshot = collect.takeSnapshot();
+    yield testFunc(product);
+    const afterSnapshot = collect.takeSnapshot();
+    const diff = collect.compareSnapshot(beforeSnapshot, afterSnapshot);
+    const notifications = collect.notifications;
+    return {
+        beforeSnapshot: Collector.stripRefsForWrapper(beforeSnapshot),
+        afterSnapshot: Collector.stripRefsForWrapper(afterSnapshot),
+        diff,
+        notifications,
+    };
+});

package/dist/utilitiesCatalogueData.d.ts

@@ -1,26 +1,32 @@
-import { CatalogueParams, GetProductParams, Model, PartsData, Prices, ProductData, ProductResponse, SelectedOption, ValidateResponse } from "./CatalogueAPI.js";
-export declare const makeCatalogueKey: (cat: CatalogueParams) => string;
-export declare const makeProductKey: (cat: CatalogueParams, pKey: string) => string;
-export declare const makeSelOptionsKey: (options: SelectedOption[]) => string;
-export declare type RootNodeSource = Model | File;
-export declare type CfgProductData = Omit<Omit<ProductData, "models">, "partsData"> & {
-    models?: RootNodeSource[];
-    partsData: Omit<PartsData, "selOptions"> & {
-        selOptions: SelectedOption[];
-    };
-};
-export declare type CfgProductResponse = Omit<ProductResponse, "productData"> & {
-    productData: CfgProductData;
-};
-/** This must be kept in sync with ValidateResponse. */
-export declare type CfgValidateResponse = Omit<ValidateResponse, "productData"> & {
-    productData: CfgProductData;
-};
-export declare function isModel(arg: any): arg is Model;
-/** Replace empty strings with "-" for compatibility with the API. */
-export declare function correctDefaultsOnCatalogueParams(catId: CatalogueParams): CatalogueParams;
-export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: Prices | undefined): number | undefined;
-export declare function comparePricesObjects(prices1: Prices | undefined, prices2: Prices | undefined): boolean;
-export declare const decodeCatalogueParams: <T extends CatalogueParams>(params: T) => T;
-export declare const decodeProductParams: <T extends GetProductParams>(params: T) => T;
+import { AdditionalProductRef, CatalogueParams, GetProductParams, MeasureParam, Model, Orientation, PartsData, Prices, ProductData, ProductResponse, SelectedOption, Transform, ValidateResponse, Vector } from "./CatalogueAPI.js";
+export declare const makeCatalogueKey: (cat: CatalogueParams) => string;
+export declare const makeProductKey: (cat: CatalogueParams, pKey: string) => string;
+export declare const makeSelOptionsKey: (options: SelectedOption[]) => string;
+export declare type RootNodeSource = Model | File;
+export declare type CfgProductData = Omit<Omit<ProductData, "models">, "partsData"> & {
+    models?: RootNodeSource[];
+    partsData: Omit<PartsData, "selOptions"> & {
+        selOptions: SelectedOption[];
+    };
+};
+export declare type CfgProductResponse = Omit<ProductResponse, "productData"> & {
+    productData: CfgProductData;
+};
+/** This must be kept in sync with ValidateResponse. */
+export declare type CfgValidateResponse = Omit<ValidateResponse, "productData"> & {
+    productData: CfgProductData;
+};
+export declare function isModel(arg: unknown): arg is Model;
+/** Replace empty strings with "-" for compatibility with the API. */
+export declare function correctDefaultsOnCatalogueParams(catId: CatalogueParams): CatalogueParams;
+export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: Prices | undefined): number | undefined;
+export declare function comparePricesObjects(prices1: Prices | undefined, prices2: Prices | undefined): boolean;
+export declare const decodeCatalogueParams: <T extends CatalogueParams>(params: T) => T;
+export declare const decodeProductParams: <T extends GetProductParams>(params: T) => T;
+export declare function isSameCatalogueParams(left: CatalogueParams, right: CatalogueParams): boolean;
+export declare function isSameVector(left: Vector, right: Vector): boolean;
+export declare function isSameOrientation(left: Orientation, right: Orientation): boolean;
+export declare function isSameAnchor(left: MeasureParam, right: MeasureParam): boolean;
+export declare function isSameTransform(left: Transform, right: Transform): boolean;
+export declare function isSameProductRef(left: AdditionalProductRef, right: AdditionalProductRef): boolean;
 //# sourceMappingURL=utilitiesCatalogueData.d.ts.map

package/dist/utilitiesCatalogueData.js

@@ -1,65 +1,162 @@
-import { shallowCompareDictionaries } from "@configura/web-utilities";
-export const makeCatalogueKey = (cat) => `${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
-export const makeProductKey = (cat, pKey) => `${makeCatalogueKey(cat)}-${pKey}`;
-export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
-    var _a;
-    const { code, numericValue, next } = option;
-    p += `_{${code}${numericValue === undefined ? "" : `_${numericValue.value}${(_a = numericValue.unit) !== null && _a !== void 0 ? _a : ""}`}`;
-    if (next === undefined) {
-        return p;
-    }
-    for (const key of Object.keys(next)) {
-        const innerOption = next[key];
-        p += `_{${key}_${makeSelOptionsKey([innerOption])}_}`;
-    }
-    p += "_}";
-    return p;
-}, "");
-export function isModel(arg) {
-    return arg.cid !== undefined && arg.uri !== undefined;
-}
-/** Replace empty strings with "-" for compatibility with the API. */
-export function correctDefaultsOnCatalogueParams(catId) {
-    // Enterprise, prdCat and vendor have to be set, so we don't try and fix those
-    return {
-        enterprise: catId.enterprise,
-        prdCat: catId.prdCat,
-        prdCatVersion: catId.prdCatVersion || "-",
-        priceList: catId.priceList || "-",
-        vendor: catId.vendor,
-    };
-}
-export function recursivelyGetPriceCodeValue(priceCodes, prices) {
-    while (prices) {
-        for (const name of priceCodes) {
-            const priceCodeUpcharge = prices === null || prices === void 0 ? void 0 : prices.values[name];
-            if (priceCodeUpcharge !== undefined) {
-                return priceCodeUpcharge;
-            }
-        }
-        prices = prices.parent;
-    }
-    return undefined;
-}
-export function comparePricesObjects(prices1, prices2) {
-    if (prices1 === undefined && prices2 === undefined) {
-        return true;
-    }
-    if (prices1 === undefined || prices2 === undefined) {
-        return false;
-    }
-    const parent1 = prices1.parent;
-    const parent2 = prices2.parent;
-    if (!comparePricesObjects(parent1, parent2)) {
-        return false;
-    }
-    return shallowCompareDictionaries(prices1.values, prices2.values);
-}
-export const decodeCatalogueParams = (params) => {
-    const decoded = Object.assign(Object.assign({}, params), { enterprise: decodeURIComponent(params.enterprise), prdCat: decodeURIComponent(params.prdCat), prdCatVersion: decodeURIComponent(params.prdCatVersion), priceList: decodeURIComponent(params.priceList), vendor: decodeURIComponent(params.vendor) });
-    return decoded;
-};
-export const decodeProductParams = (params) => {
-    const decoded = Object.assign(Object.assign({}, decodeCatalogueParams(params)), { partNumber: decodeURIComponent(params.partNumber) });
-    return decoded;
-};
+import { shallowCompareDictionaries } from "@configura/web-utilities";
+export const makeCatalogueKey = (cat) => `${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
+export const makeProductKey = (cat, pKey) => `${makeCatalogueKey(cat)}-${pKey}`;
+export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
+    var _a;
+    const { code, numericValue, next } = option;
+    p += `_{${code}`;
+    p += numericValue === undefined ? "" : `_${numericValue.value}${(_a = numericValue.unit) !== null && _a !== void 0 ? _a : ""}`;
+    if (next === undefined) {
+        return p;
+    }
+    for (const key of Object.keys(next)) {
+        const innerOption = next[key];
+        p += `_{${key}_${makeSelOptionsKey([innerOption])}_}`;
+    }
+    p += "_}";
+    return p;
+}, "");
+export function isModel(arg) {
+    return typeof arg === "object" && arg !== null && "cid" in arg && "uri" in arg;
+}
+/** Replace empty strings with "-" for compatibility with the API. */
+export function correctDefaultsOnCatalogueParams(catId) {
+    // Enterprise, prdCat and vendor have to be set, so we don't try and fix those
+    return {
+        enterprise: catId.enterprise,
+        prdCat: catId.prdCat,
+        prdCatVersion: catId.prdCatVersion || "-",
+        priceList: catId.priceList || "-",
+        vendor: catId.vendor,
+    };
+}
+export function recursivelyGetPriceCodeValue(priceCodes, prices) {
+    while (prices) {
+        for (const name of priceCodes) {
+            const priceCodeUpcharge = prices === null || prices === void 0 ? void 0 : prices.values[name];
+            if (priceCodeUpcharge !== undefined) {
+                return priceCodeUpcharge;
+            }
+        }
+        prices = prices.parent;
+    }
+    return undefined;
+}
+export function comparePricesObjects(prices1, prices2) {
+    if (prices1 === undefined && prices2 === undefined) {
+        return true;
+    }
+    if (prices1 === undefined || prices2 === undefined) {
+        return false;
+    }
+    const parent1 = prices1.parent;
+    const parent2 = prices2.parent;
+    if (!comparePricesObjects(parent1, parent2)) {
+        return false;
+    }
+    return shallowCompareDictionaries(prices1.values, prices2.values);
+}
+export const decodeCatalogueParams = (params) => (Object.assign(Object.assign({}, params), { enterprise: decodeURIComponent(params.enterprise), prdCat: decodeURIComponent(params.prdCat), prdCatVersion: decodeURIComponent(params.prdCatVersion), priceList: decodeURIComponent(params.priceList), vendor: decodeURIComponent(params.vendor) }));
+export const decodeProductParams = (params) => (Object.assign(Object.assign({}, decodeCatalogueParams(params)), { partNumber: decodeURIComponent(params.partNumber) }));
+export function isSameCatalogueParams(left, right) {
+    return (left.enterprise === right.enterprise &&
+        left.prdCat === right.prdCat &&
+        left.prdCatVersion === right.prdCatVersion &&
+        left.priceList === right.priceList &&
+        left.vendor === right.vendor);
+}
+export function isSameVector(left, right) {
+    return left.x === right.x && left.y === right.y && left.z === right.z;
+}
+export function isSameOrientation(left, right) {
+    return left.pitch === right.pitch && left.roll === right.roll && left.yaw === right.yaw;
+}
+export function isSameAnchor(left, right) {
+    var _a, _b;
+    if (left.code !== right.code) {
+        return false;
+    }
+    if (left.anchorPoint !== right.anchorPoint) {
+        return false;
+    }
+    const leftMeasurePriorities = (_a = left.measurePriority) !== null && _a !== void 0 ? _a : [];
+    const rightMeasurePriorities = (_b = right.measurePriority) !== null && _b !== void 0 ? _b : [];
+    if (leftMeasurePriorities.length !== rightMeasurePriorities.length) {
+        return false;
+    }
+    if (leftMeasurePriorities.some((p, i) => p.url !== rightMeasurePriorities[i].url)) {
+        return false;
+    }
+    return true;
+}
+export function isSameTransform(left, right) {
+    const leftTransformPos = left.pos;
+    const rightTransformPos = right.pos;
+    const leftTransformRot = left.rot;
+    const rightTransformRot = right.rot;
+    const leftTransformScale = left.scale;
+    const rightTransformScale = right.scale;
+    if ((leftTransformPos === undefined) !== (rightTransformPos === undefined)) {
+        return false;
+    }
+    if ((leftTransformRot === undefined) !== (rightTransformRot === undefined)) {
+        return false;
+    }
+    if ((leftTransformScale === undefined) !== (rightTransformScale === undefined)) {
+        return false;
+    }
+    if (leftTransformPos !== undefined &&
+        rightTransformPos !== undefined &&
+        !isSameVector(leftTransformPos, rightTransformPos)) {
+        return false;
+    }
+    if (leftTransformRot !== undefined &&
+        rightTransformRot !== undefined &&
+        !isSameOrientation(leftTransformRot, rightTransformRot)) {
+        return false;
+    }
+    if (leftTransformScale !== undefined &&
+        rightTransformScale !== undefined &&
+        !isSameVector(leftTransformScale, rightTransformScale)) {
+        return false;
+    }
+    return true;
+}
+export function isSameProductRef(left, right) {
+    if (left.refKey !== right.refKey) {
+        return false;
+    }
+    if (left.partNumber !== right.partNumber) {
+        return false;
+    }
+    if (!isSameCatalogueParams(left.catId, right.catId)) {
+        return false;
+    }
+    if (left.refDescription !== right.refDescription) {
+        return false;
+    }
+    const leftAnchor = left.anchor;
+    const rightAnchor = right.anchor;
+    if ((leftAnchor === undefined) !== (rightAnchor === undefined)) {
+        return false;
+    }
+    if (leftAnchor !== undefined &&
+        rightAnchor !== undefined &&
+        !isSameAnchor(leftAnchor, rightAnchor)) {
+        return false;
+    }
+    const leftTransform = left.transform;
+    const rightTransform = right.transform;
+    if ((leftTransform === undefined) !== (rightTransform === undefined)) {
+        return false;
+    }
+    if (leftTransform !== undefined &&
+        rightTransform !== undefined &&
+        !isSameTransform(leftTransform, rightTransform)) {
+        return false;
+    }
+    if (left.optional !== right.optional) {
+        return false;
+    }
+    return true;
+}

package/dist/utilitiesCataloguePermission.d.ts

@@ -1,40 +1,38 @@
-import { CatalogueParams, CataloguePermission } from "./CatalogueAPI.js";
-interface CataloguePermissionByEnterpriseKey {
-    [key: string]: CataloguePermission[];
-}
-export declare const groupAndSortCataloguePermissions: (cataloguePermissions: CataloguePermission[]) => CataloguePermissionByEnterpriseKey;
-export declare const isParamSet: (param: string) => boolean;
-export declare const createCataloguePermissionsFilter: (enterprise: string, prdCat: string, prdCatVersion: string, priceList: string, vendor: string) => (perm: CataloguePermission) => boolean;
-/**
- * Sometimes you will want to use the latest available prdCatVersion. This method will
- * find the highest prdCatVersion version in the cataloguePermissions. If the versions are
- * numeric ("1", "4.3", "0.2") they will be numerically compared, otherwise non localized
- * string compare.
- * @param cataloguePermissions
- * @param enterprise
- * @param prdCat
- * @param priceList
- * @param vendor
- */
-export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: CataloguePermission[], enterprise: string, prdCat: string, priceList: string, vendor: string) => string | undefined;
-/**
- * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
- * This method will, if the prdCatVersion is not set, fetch the highest available from the catalogue
- * permissions. If it fails to find any applicable permissions the original value is returned.
- * @param auth
- * @param params
- */
-export declare const getPrdCatVersionOrLatestFromPermissions: (params: CatalogueParams, cataloguePermissions: CataloguePermission[]) => string;
-/**
- * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
- * This method will, if the prdCatVersion is not set, fetch the highest available from the
- * cataloguePermissions and insert it into a copy of the original params. If it fails to find any
- * applicable auth-permissions the original value is returned.
- * @param auth
- * @param params
- */
-export declare const fillMissingPrdCatVersionFromPermissions: <T extends CatalogueParams>(params: T, cataloguePermissions: CataloguePermission[]) => T & {
-    prdCatVersion: string;
-};
-export {};
+import { CatalogueParams, CataloguePermission } from "./CatalogueAPI.js";
+interface CataloguePermissionByEnterpriseKey {
+    [key: string]: CataloguePermission[];
+}
+export declare const groupAndSortCataloguePermissions: (cataloguePermissions: CataloguePermission[]) => CataloguePermissionByEnterpriseKey;
+export declare const isParamSet: (param: string) => boolean;
+export declare const createCataloguePermissionsFilter: (enterprise: string, prdCat: string, prdCatVersion: string, priceList: string, vendor: string) => (perm: CataloguePermission) => boolean;
+/**
+ * Sometimes you will want to use the latest available prdCatVersion. This method will
+ * find the highest prdCatVersion version in the cataloguePermissions. If the versions are
+ * numeric ("1", "4.3", "0.2") they will be numerically compared, otherwise non localized
+ * string compare.
+ * @param cataloguePermissions
+ * @param enterprise
+ * @param prdCat
+ * @param priceList
+ * @param vendor
+ */
+export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: CataloguePermission[], enterprise: string, prdCat: string, priceList: string, vendor: string) => string | undefined;
+/**
+ * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
+ * This method will, if the prdCatVersion is not set, fetch the highest available from the catalogue
+ * permissions. If it fails to find any applicable permissions the original value is returned.
+ * @param auth
+ * @param params
+ */
+export declare const getPrdCatVersionOrLatestFromPermissions: (params: CatalogueParams, cataloguePermissions: CataloguePermission[]) => string;
+/**
+ * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
+ * This method will, if the prdCatVersion is not set, fetch the highest available from the
+ * cataloguePermissions and insert it into a copy of the original params. If it fails to find any
+ * applicable auth-permissions the original value is returned.
+ * @param auth
+ * @param params
+ */
+export declare const fillMissingPrdCatVersionFromPermissions: <T extends CatalogueParams>(params: T, cataloguePermissions: CataloguePermission[]) => T;
+export {};
 //# sourceMappingURL=utilitiesCataloguePermission.d.ts.map