sodas-sdk 1.3.11 → 1.4.0

package/dist/index.node.js

@@ -5542,6 +5542,30 @@ class Dataset extends _dcatResource__WEBPACK_IMPORTED_MODULE_4__["default"] {
             throw new _core_error__WEBPACK_IMPORTED_MODULE_0__.UnexpectedResponseFormatError(response);
         });
     }
+    static getRDF(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, depth = 1) {
+            // @ts-ignore - static helper expects SODAS_SDK_CLASS constructor type
+            (0,_sodasSDKClass__WEBPACK_IMPORTED_MODULE_3__.throwErrorIfAPIURLNotSetForStatic)(this);
+            const url = `${Dataset.API_URL}/rdf`;
+            let response;
+            try {
+                response = yield axios__WEBPACK_IMPORTED_MODULE_6__["default"].get(url, {
+                    headers: Object.assign({ Accept: "text/turtle" }, (Dataset.BEARER_TOKEN && {
+                        Authorization: `Bearer ${Dataset.BEARER_TOKEN}`,
+                    })),
+                    params: { id, depth },
+                    responseType: "text",
+                });
+            }
+            catch (error) {
+                (0,_core_util__WEBPACK_IMPORTED_MODULE_2__.handleAxiosError)(error);
+            }
+            if (typeof response.data === "string") {
+                return response.data;
+            }
+            throw new _core_error__WEBPACK_IMPORTED_MODULE_0__.UnexpectedResponseFormatError(response);
+        });
+    }
     static searchDBRecords(searchKeyword_1) {
         return __awaiter(this, arguments, void 0, function* (searchKeyword, pageNumber = 1, pageSize = 10, sortOrder = _core_type__WEBPACK_IMPORTED_MODULE_1__.SortOrder.DESC) {
             if (!searchKeyword || !searchKeyword.trim()) {
@@ -5997,6 +6021,30 @@ class DatasetSeries extends _dcatResource__WEBPACK_IMPORTED_MODULE_5__["default"
         DatasetSeries.API_URL = `${url}/datasetseries`;
         DatasetSeries.LIST_URL = `${DatasetSeries.API_URL}/list`;
     }
+    static getRDF(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, depth = 1) {
+            // @ts-ignore - static helper expects SODAS_SDK_CLASS constructor type
+            (0,_sodasSDKClass__WEBPACK_IMPORTED_MODULE_3__.throwErrorIfAPIURLNotSetForStatic)(this);
+            const url = `${DatasetSeries.API_URL}/rdf`;
+            let response;
+            try {
+                response = yield axios__WEBPACK_IMPORTED_MODULE_6__["default"].get(url, {
+                    headers: Object.assign({ Accept: "text/turtle" }, (DatasetSeries.BEARER_TOKEN && {
+                        Authorization: `Bearer ${DatasetSeries.BEARER_TOKEN}`,
+                    })),
+                    params: { id, depth },
+                    responseType: "text",
+                });
+            }
+            catch (error) {
+                (0,_core_util__WEBPACK_IMPORTED_MODULE_2__.handleAxiosError)(error);
+            }
+            if (typeof response.data === "string") {
+                return response.data;
+            }
+            throw new _core_error__WEBPACK_IMPORTED_MODULE_0__.UnexpectedResponseFormatError(response);
+        });
+    }
     static listUserDBRecords() {
         return __awaiter(this, arguments, void 0, function* (pageNumber = 1, pageSize = 10, sortOrder = _core_type__WEBPACK_IMPORTED_MODULE_1__.SortOrder.DESC) {
             // @ts-ignore - static helper expects SODAS_SDK_CLASS constructor type
@@ -7815,26 +7863,345 @@ class SODAS_SDK_CLASS {
 
 /***/ }),
 
-/***/ "./lib/SODAS_SDK_FILE/artifactFile.ts":
-/*!********************************************!*\
-  !*** ./lib/SODAS_SDK_FILE/artifactFile.ts ***!
-  \********************************************/
+/***/ "./lib/SODAS_SDK_CLASS/template/validation.ts":
+/*!****************************************************!*\
+  !*** ./lib/SODAS_SDK_CLASS/template/validation.ts ***!
+  \****************************************************/
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   EXPECTED_TYPE: () => (/* binding */ EXPECTED_TYPE),
+/* harmony export */   VALIDATION_TYPE: () => (/* binding */ VALIDATION_TYPE),
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _sodasSDKFile__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sodasSDKFile */ "./lib/SODAS_SDK_FILE/sodasSDKFile.ts");
+/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! axios */ "./node_modules/axios/lib/axios.js");
+/* harmony import */ var _core_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../core/error */ "./lib/core/error.ts");
+/* harmony import */ var _core_type__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../core/type */ "./lib/core/type.ts");
+/* harmony import */ var _core_util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../core/util */ "./lib/core/util.ts");
+/* harmony import */ var _governanceClass__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../governanceClass */ "./lib/SODAS_SDK_CLASS/governanceClass.ts");
+/* harmony import */ var _sodasSDKClass__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../sodasSDKClass */ "./lib/SODAS_SDK_CLASS/sodasSDKClass.ts");
+var __awaiter = (undefined && undefined.__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());
+    });
+};
+
+
+
 
-class ArtifactFile extends _sodasSDKFile__WEBPACK_IMPORTED_MODULE_0__["default"] {
+
+
+var VALIDATION_TYPE;
+(function (VALIDATION_TYPE) {
+    VALIDATION_TYPE["DATA_TYPE"] = "data_type";
+    VALIDATION_TYPE["RANGE"] = "range";
+    VALIDATION_TYPE["PATTERN"] = "pattern";
+    VALIDATION_TYPE["UNIQUENESS"] = "uniqueness";
+    VALIDATION_TYPE["COMPLETENESS"] = "completeness";
+    VALIDATION_TYPE["LENGTH"] = "length";
+    VALIDATION_TYPE["ALLOWED_VALUES"] = "allowed_values";
+    VALIDATION_TYPE["OUTLIER"] = "outlier";
+    VALIDATION_TYPE["STATISTICAL"] = "statistical";
+})(VALIDATION_TYPE || (VALIDATION_TYPE = {}));
+var EXPECTED_TYPE;
+(function (EXPECTED_TYPE) {
+    EXPECTED_TYPE["NUMERIC"] = "numeric";
+    EXPECTED_TYPE["STRING"] = "string";
+    EXPECTED_TYPE["DATETIME"] = "datetime";
+})(EXPECTED_TYPE || (EXPECTED_TYPE = {}));
+class ValidationTemplate extends _governanceClass__WEBPACK_IMPORTED_MODULE_3__["default"] {
     static configureAPIURL(url) {
-        ArtifactFile.UPLOAD_URL = `${url}/api/v1/governance/open-reference-model/resource-descriptor/artifact/upload`;
-        ArtifactFile.REMOVE_URL = `${url}/api/v1/governance/open-reference-model/resource-descriptor/artifact/remove?id=`;
-        ArtifactFile.DOWNLOAD_URL = `${url}/artifacts`;
+        const PREFIX = "api/v1/governance/template";
+        ValidationTemplate.API_URL = `${url}/${PREFIX}/validation`;
+        ValidationTemplate.LIST_URL = `${ValidationTemplate.API_URL}/list`;
+        ValidationTemplate.GET_URL = `${ValidationTemplate.API_URL}/get`;
+        ValidationTemplate.CREATE_URL = `${ValidationTemplate.API_URL}/create`;
+        ValidationTemplate.UPDATE_URL = `${ValidationTemplate.API_URL}/update`;
+        ValidationTemplate.DELETE_URL = `${ValidationTemplate.API_URL}/remove`;
+    }
+    toDTO() {
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, super.toDTO()), { name: this.Name }), (this.ValidationRules && { validationRules: this.ValidationRules })), (this.Description && { description: this.Description }));
+    }
+    populateFromFormData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new _core_error__WEBPACK_IMPORTED_MODULE_0__.NeedToImplementError();
+        });
+    }
+    populateFromDTO(dto) {
+        const _super = Object.create(null, {
+            populateFromDTO: { get: () => super.populateFromDTO }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.populateFromDTO.call(this, dto);
+            const validationTemplateDTO = dto;
+            this.ValidationRules = validationTemplateDTO.validationRules;
+            this.Name = validationTemplateDTO.name;
+            this.Description = validationTemplateDTO.description;
+        });
+    }
+    static listDBRecords() {
+        return __awaiter(this, arguments, void 0, function* (pageNumber = 1, pageSize = 10, sortOrder = _core_type__WEBPACK_IMPORTED_MODULE_1__.SortOrder.DESC, vocabularyID) {
+            (0,_sodasSDKClass__WEBPACK_IMPORTED_MODULE_4__.throwErrorIfAPIURLNotSetForStatic)(ValidationTemplate);
+            try {
+                const response = yield axios__WEBPACK_IMPORTED_MODULE_5__["default"].get(ValidationTemplate.LIST_URL, {
+                    params: {
+                        offset: (pageNumber - 1) * pageSize,
+                        limit: pageSize,
+                        ordered: sortOrder,
+                        vocabularyId: vocabularyID,
+                    },
+                    // headers,
+                });
+                return yield ValidationTemplate.listResponseToPaginatedResponse(response);
+            }
+            catch (error) {
+                (0,_core_util__WEBPACK_IMPORTED_MODULE_2__.handleAxiosError)(error);
+            }
+        });
+    }
+    get name() {
+        return this.Name;
+    }
+    set name(value) {
+        this.Name = value;
+    }
+    get description() {
+        return this.Description;
+    }
+    set description(value) {
+        this.Description = value;
+    }
+    get validationRules() {
+        return this.ValidationRules;
+    }
+    set validationRules(value) {
+        this.ValidationRules = value;
+    }
+    static parseValidationRules(rawRules) {
+        return rawRules.map((rule) => {
+            const baseRule = {
+                column: rule.column,
+                name: rule.name,
+                type: rule.type,
+            };
+            switch (rule.type) {
+                case VALIDATION_TYPE.COMPLETENESS:
+                    return Object.assign(Object.assign({}, baseRule), { type: VALIDATION_TYPE.COMPLETENESS, min_completeness: rule.min_completeness, weight: rule.weight });
+                case VALIDATION_TYPE.DATA_TYPE:
+                    return Object.assign(Object.assign({}, baseRule), { type: VALIDATION_TYPE.DATA_TYPE, expected_type: rule.expected_type, weight: rule.weight });
+                case VALIDATION_TYPE.PATTERN:
+                    return Object.assign(Object.assign({}, baseRule), { type: VALIDATION_TYPE.PATTERN, pattern: rule.pattern, weight: rule.weight });
+                case VALIDATION_TYPE.UNIQUENESS:
+                    return Object.assign(Object.assign({}, baseRule), { type: VALIDATION_TYPE.UNIQUENESS, weight: rule.weight });
+                default:
+                    return baseRule;
+            }
+        });
+    }
+    ensureValidationRulesInitialized() {
+        if (!this.ValidationRules) {
+            this.ValidationRules = [];
+        }
+    }
+    createRule(type) {
+        this.ensureValidationRulesInitialized();
+        let rule;
+        const baseRule = {
+            column: "",
+            name: "",
+            type,
+        };
+        switch (type) {
+            case VALIDATION_TYPE.COMPLETENESS:
+                rule = Object.assign(Object.assign({}, baseRule), { min_completeness: 0, weight: 0 });
+                break;
+            case VALIDATION_TYPE.DATA_TYPE:
+                rule = Object.assign(Object.assign({}, baseRule), { expected_type: EXPECTED_TYPE.STRING, weight: 0 });
+                break;
+            case VALIDATION_TYPE.PATTERN:
+                rule = Object.assign(Object.assign({}, baseRule), { pattern: "", weight: 0 });
+                break;
+            case VALIDATION_TYPE.UNIQUENESS:
+                rule = Object.assign(Object.assign({}, baseRule), { weight: 0 });
+                break;
+            default:
+                rule = baseRule;
+        }
+        this.ValidationRules.push(rule);
+        return rule;
+    }
+    deleteRuleAt(index) {
+        if (!this.ValidationRules) {
+            return;
+        }
+        if (index < 0 || index >= this.ValidationRules.length) {
+            return;
+        }
+        this.ValidationRules.splice(index, 1);
+    }
+    deleteRuleByTypeAt(type, index) {
+        if (!this.ValidationRules) {
+            return;
+        }
+        if (index < 0) {
+            return;
+        }
+        let current = 0;
+        for (let i = 0; i < this.ValidationRules.length; i++) {
+            if (this.ValidationRules[i].type === type) {
+                if (current === index) {
+                    this.ValidationRules.splice(i, 1);
+                    return;
+                }
+                current++;
+            }
+        }
+    }
+    static groupValidationRulesByColumn(rules) {
+        return rules.reduce((acc, rule) => {
+            const column = rule.column;
+            if (!acc[column]) {
+                acc[column] = [];
+            }
+            acc[column].push(rule);
+            return acc;
+        }, {});
+    }
+    static groupValidationRulesByType(rules) {
+        return rules.reduce((acc, rule) => {
+            const type = rule.type;
+            if (!acc[type]) {
+                acc[type] = [];
+            }
+            acc[type].push(rule);
+            return acc;
+        }, {});
+    }
+    /**
+     * Parse escaped JSON string containing validation_rules to ValidationRule[]
+     * @param escapedString - Escaped JSON string like "validation_rules\":[{\"column\":\"class_label\",...}]"
+     * @returns Parsed ValidationRule array
+     */
+    static parseValidationRulesFromEscapedString(escapedString) {
+        let processedString = escapedString.trim();
+        // Remove surrounding quotes if present (e.g., '"{"validation_rules":...}"' -> '{"validation_rules":...}')
+        // Check for both single and double quotes
+        if (((processedString.startsWith('"') && processedString.endsWith('"')) ||
+            (processedString.startsWith("'") && processedString.endsWith("'"))) &&
+            processedString.length > 1) {
+            processedString = processedString.slice(1, -1).trim();
+        }
+        // Unescape the string (replace \" with ")
+        // Handle both \" and \\\" cases to avoid double-escaping issues
+        let unescapedString = processedString;
+        // First handle \\\" -> \"
+        unescapedString = unescapedString.replace(/\\\\"/g, '\\"');
+        // Then handle \" -> "
+        unescapedString = unescapedString.replace(/\\"/g, '"');
+        // Try to parse as JSON
+        let parsed;
+        try {
+            // First try parsing directly
+            parsed = JSON.parse(unescapedString);
+        }
+        catch (error) {
+            // If parsing fails, try different approaches
+            const trimmed = unescapedString.trim();
+            // If it starts with "validation_rules" but is not wrapped in braces
+            if (trimmed.startsWith('"validation_rules"') ||
+                trimmed.startsWith("validation_rules")) {
+                // Try wrapping in braces
+                const wrapped = trimmed.startsWith('"')
+                    ? `{${trimmed}}`
+                    : `{"${trimmed}}`;
+                try {
+                    parsed = JSON.parse(wrapped);
+                }
+                catch (e) {
+                    // If still fails, try without the leading quote
+                    const withoutQuote = trimmed.replace(/^"/, "");
+                    parsed = JSON.parse(`{"${withoutQuote}`);
+                }
+            }
+            else if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+                // Already looks like JSON object, try parsing again after trimming
+                parsed = JSON.parse(trimmed);
+            }
+            else {
+                throw error;
+            }
+        }
+        // Extract validation_rules array
+        let validationRules;
+        // If it's already an array, use it directly
+        if (Array.isArray(parsed)) {
+            validationRules = parsed;
+        }
+        else if (parsed.validation_rules) {
+            // If it's an object with validation_rules property
+            validationRules = parsed.validation_rules;
+        }
+        else if (typeof parsed === "object") {
+            // If it's an object but no validation_rules property, try to use it as is
+            validationRules = parsed;
+        }
+        else {
+            throw new Error("Invalid format: validation_rules not found");
+        }
+        // Ensure validationRules is an array
+        if (!Array.isArray(validationRules)) {
+            throw new Error("Invalid format: validation_rules must be an array");
+        }
+        const parsedRules = ValidationTemplate.parseValidationRules(validationRules);
+        parsedRules._escapedString = escapedString;
+        return parsedRules;
+    }
+    /**
+     * Convert ValidationRule[] to escaped JSON string
+     * @param rules - ValidationRule array to stringify
+     * @returns Escaped JSON string with format: "{\"validation_rules\":[...]}"
+     */
+    static stringifyValidationRulesToEscapedString(rules) {
+        // Convert ValidationRule[] to plain objects for JSON serialization
+        const plainRules = rules.map((rule) => {
+            const plainRule = {
+                column: rule.column,
+                name: rule.name,
+                type: rule.type,
+            };
+            switch (rule.type) {
+                case VALIDATION_TYPE.COMPLETENESS:
+                    const completenessRule = rule;
+                    return Object.assign(Object.assign({}, plainRule), { min_completeness: completenessRule.min_completeness, weight: completenessRule.weight });
+                case VALIDATION_TYPE.DATA_TYPE:
+                    const dataTypeRule = rule;
+                    return Object.assign(Object.assign({}, plainRule), { expected_type: dataTypeRule.expected_type, weight: dataTypeRule.weight });
+                case VALIDATION_TYPE.PATTERN:
+                    const patternRule = rule;
+                    return Object.assign(Object.assign({}, plainRule), { pattern: patternRule.pattern, weight: patternRule.weight });
+                case VALIDATION_TYPE.UNIQUENESS:
+                    const uniquenessRule = rule;
+                    return Object.assign(Object.assign({}, plainRule), { weight: uniquenessRule.weight });
+                default:
+                    return plainRule;
+            }
+        });
+        // Create object with validation_rules property
+        if (rules._escapedString) {
+            return rules._escapedString;
+        }
+        const obj = { validation_rules: plainRules };
+        const jsonString = JSON.stringify(obj);
+        const escaped = jsonString.replace(/"/g, '\\"');
+        return '"' + escaped + '"';
     }
 }
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ArtifactFile);
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ValidationTemplate);
 
 
 /***/ }),
@@ -8106,7 +8473,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _SODAS_SDK_CLASS_DCAT_distribution__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/DCAT/distribution */ "./lib/SODAS_SDK_CLASS/DCAT/distribution.ts");
 /* harmony import */ var _SODAS_SDK_CLASS_dictionary_term__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/dictionary/term */ "./lib/SODAS_SDK_CLASS/dictionary/term.ts");
 /* harmony import */ var _SODAS_SDK_CLASS_dictionary_vocabulary__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/dictionary/vocabulary */ "./lib/SODAS_SDK_CLASS/dictionary/vocabulary.ts");
-/* harmony import */ var _SODAS_SDK_FILE_artifactFile__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../SODAS_SDK_FILE/artifactFile */ "./lib/SODAS_SDK_FILE/artifactFile.ts");
+/* harmony import */ var _SODAS_SDK_CLASS_template_validation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/template/validation */ "./lib/SODAS_SDK_CLASS/template/validation.ts");
 /* harmony import */ var _SODAS_SDK_FILE_dataFile__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../SODAS_SDK_FILE/dataFile */ "./lib/SODAS_SDK_FILE/dataFile.ts");
 /* harmony import */ var _SODAS_SDK_FILE_thumbnailFile__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../SODAS_SDK_FILE/thumbnailFile */ "./lib/SODAS_SDK_FILE/thumbnailFile.ts");
 /* harmony import */ var _error__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./error */ "./lib/core/error.ts");
@@ -8196,9 +8563,9 @@ class Config {
             console.error("DATAHUB_API_URL not found in config");
         }
         if (this.governanceBaseUrl) {
-            _SODAS_SDK_FILE_artifactFile__WEBPACK_IMPORTED_MODULE_6__["default"].configureAPIURL(SLASH_DELETED_GOVERNANCE_PORTAL_API_URL);
             _SODAS_SDK_CLASS_dictionary_vocabulary__WEBPACK_IMPORTED_MODULE_5__["default"].configureAPIURL(SLASH_DELETED_GOVERNANCE_PORTAL_API_URL);
             _SODAS_SDK_CLASS_dictionary_term__WEBPACK_IMPORTED_MODULE_4__["default"].configureAPIURL(SLASH_DELETED_GOVERNANCE_PORTAL_API_URL);
+            _SODAS_SDK_CLASS_template_validation__WEBPACK_IMPORTED_MODULE_6__["default"].configureAPIURL(SLASH_DELETED_GOVERNANCE_PORTAL_API_URL);
         }
         else {
             console.error("GOVERNANCE_API_URL not found in config");
@@ -8472,6 +8839,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _SODAS_SDK_CLASS_DCAT_distribution__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/DCAT/distribution */ "./lib/SODAS_SDK_CLASS/DCAT/distribution.ts");
 /* harmony import */ var _SODAS_SDK_CLASS_dictionary_term__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/dictionary/term */ "./lib/SODAS_SDK_CLASS/dictionary/term.ts");
 /* harmony import */ var _SODAS_SDK_CLASS_dictionary_vocabulary__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/dictionary/vocabulary */ "./lib/SODAS_SDK_CLASS/dictionary/vocabulary.ts");
+/* harmony import */ var _SODAS_SDK_CLASS_template_validation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../SODAS_SDK_CLASS/template/validation */ "./lib/SODAS_SDK_CLASS/template/validation.ts");
+
 
 
 
@@ -8487,6 +8856,7 @@ __webpack_require__.r(__webpack_exports__);
 function setGovernanceBearerToken(token) {
     _SODAS_SDK_CLASS_dictionary_vocabulary__WEBPACK_IMPORTED_MODULE_5__["default"].BEARER_TOKEN = token;
     _SODAS_SDK_CLASS_dictionary_term__WEBPACK_IMPORTED_MODULE_4__["default"].BEARER_TOKEN = token;
+    _SODAS_SDK_CLASS_template_validation__WEBPACK_IMPORTED_MODULE_6__["default"].BEARER_TOKEN = token;
 }
 function setLegacyDatahubBearerToken(token) {
     _SODAS_SDK_CLASS_DCAT_dataset__WEBPACK_IMPORTED_MODULE_1__["default"].BEARER_TOKEN = token;