sodas-sdk 1.5.1 → 1.6.0

package/dist/SODAS_SDK_CLASS/DCAT/dataService.d.ts

@@ -1,5 +1,5 @@
 import { IDType, PaginatedResponse, SortOrder } from "../../core/type";
-import { DCAT_MODEL_DTO } from "../dcatClass";
+import { PROFILE_MODEL_DTO } from "../profileModel";
 import DCAT_RESOURCE, { DCAT_RESOURCE_DTO } from "./dcatResource";
 export interface DataServiceDTO extends DCAT_RESOURCE_DTO {
     DataServiceID?: string;
@@ -23,7 +23,7 @@ declare class DataService extends DCAT_RESOURCE {
     static listUserDBRecords(pageNumber?: number, pageSize?: number, sortOrder?: SortOrder): Promise<PaginatedResponse<DataService>>;
     static searchDBRecords(searchKeyword: string, pageNumber?: number, pageSize?: number, sortOrder?: SortOrder): Promise<PaginatedResponse<DataService>>;
     toDTO(): DataServiceDTO;
-    populateFromDTO(dto: DCAT_MODEL_DTO): Promise<void>;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
     get dataServiceID(): IDType;
     get endpointURL(): string;
     set endpointURL(value: string);

package/dist/SODAS_SDK_CLASS/DCAT/dataset.d.ts

@@ -1,5 +1,5 @@
 import { IDType, PaginatedResponse, SortOrder } from "../../core/type";
-import { DCAT_MODEL_DTO } from "../dcatClass";
+import { PROFILE_MODEL_DTO } from "../profileModel";
 import DCAT_RESOURCE, { DCAT_RESOURCE_DTO } from "./dcatResource";
 import Distribution from "./distribution";
 export interface DatasetDTO extends DCAT_RESOURCE_DTO {
@@ -46,7 +46,7 @@ declare class Dataset extends DCAT_RESOURCE {
     static getRDF(id: string, depth?: number): Promise<string>;
     static searchDBRecords(searchKeyword: string, pageNumber?: number, pageSize?: number, sortOrder?: SortOrder): Promise<PaginatedResponse<Dataset>>;
     toDTO(): DatasetDTO;
-    populateFromDTO(dto: DCAT_MODEL_DTO): Promise<void>;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
     populateDistributionFromDTO(dto: DatasetDTO): Promise<void>;
     static syncToCurrentHub(dataset: Dataset): Promise<void>;
     populateToSync(source: Dataset): void;

package/dist/SODAS_SDK_CLASS/DCAT/datasetSeries.d.ts

@@ -1,5 +1,5 @@
 import { IDType, PaginatedResponse, SortOrder } from "../../core/type";
-import { DCAT_MODEL_DTO } from "../dcatClass";
+import { PROFILE_MODEL_DTO } from "../profileModel";
 import Dataset from "./dataset";
 import DCAT_RESOURCE, { DCAT_RESOURCE_DTO } from "./dcatResource";
 interface DatasetSeriesDTO extends DCAT_RESOURCE_DTO {
@@ -51,7 +51,7 @@ declare class DatasetSeries extends DCAT_RESOURCE {
     static listUserDBRecords(pageNumber?: number, pageSize?: number, sortOrder?: SortOrder): Promise<PaginatedResponse<DatasetSeries>>;
     static searchDBRecords(searchKeyword: string, pageNumber?: number, pageSize?: number, sortOrder?: SortOrder): Promise<PaginatedResponse<DatasetSeries>>;
     toDTO(): DatasetSeriesDTO;
-    populateFromDTO(dto: DCAT_MODEL_DTO): Promise<void>;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
     populateSeriesMembersFromDTO(dto: DatasetSeriesDTO): Promise<void>;
     deleteDBRecord(): Promise<void>;
     appendSeriesMember(dataset: Dataset): void;

package/dist/SODAS_SDK_CLASS/DCAT/dcatResource.d.ts

@@ -1,8 +1,8 @@
-import { ExtraMetadataType, MultiLanguageField, MultiLanguageKeywords } from "../../core/type";
+import { ExtraMetadataType, MultiLanguageField, MultiLanguageKeywords, QualityMetadataType } from "../../core/type";
 import ThumbnailFile from "../../SODAS_SDK_FILE/thumbnailFile";
-import DCAT_MODEL, { DCAT_MODEL_DTO } from "../dcatClass";
+import PROFILE_MODEL, { PROFILE_MODEL_DTO } from "../profileModel";
 import VersionInfo, { VersionInfoDTO } from "./versionInfo";
-export interface DCAT_RESOURCE_DTO extends DCAT_MODEL_DTO {
+export interface DCAT_RESOURCE_DTO extends PROFILE_MODEL_DTO {
     ResourceType?: string;
     AssetID?: string;
     DatahubID?: string;
@@ -32,9 +32,10 @@ export interface DCAT_RESOURCE_DTO extends DCAT_MODEL_DTO {
     HasPolicy?: any[];
     IssuerID?: string;
     ExtraMetadata?: ExtraMetadataType;
+    QualityMetadata?: QualityMetadataType;
     VersionInfo?: VersionInfoDTO[];
 }
-declare abstract class DCAT_RESOURCE extends DCAT_MODEL {
+declare abstract class DCAT_RESOURCE extends PROFILE_MODEL {
     protected Thumbnail: ThumbnailFile;
     private ResourceType;
     private AssetID;
@@ -65,9 +66,10 @@ declare abstract class DCAT_RESOURCE extends DCAT_MODEL {
     private HasPolicy;
     private IssuerID;
     private ExtraMetadata;
+    private QualityMetadata;
     private VersionInfos;
     toDTO(): DCAT_RESOURCE_DTO;
-    populateFromDTO(dto: DCAT_MODEL_DTO): Promise<void>;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
     populateVersionInfoFromDTO(dto: DCAT_RESOURCE_DTO): Promise<void>;
     createDBRecord(): Promise<void>;
     updateDBRecord(): Promise<void>;
@@ -117,6 +119,8 @@ declare abstract class DCAT_RESOURCE extends DCAT_MODEL {
     set issuerID(value: string);
     setExtraMetadata(name: string, value: string): void;
     getExtraMetadata(name: string): string | undefined;
+    setQualityMetadata(name: string, value: string): void;
+    getQualityMetadata(name: string): string | undefined;
     getTitle(languageCode?: string): string;
     setTitle(title: string, languageCode?: string): void;
     removeTitle(languageCode?: string): void;

package/dist/SODAS_SDK_CLASS/DCAT/distribution.d.ts

@@ -1,6 +1,6 @@
 import { IDType, MultiLanguageField } from "../../core/type";
-import DCAT_MODEL, { DCAT_MODEL_DTO } from "../dcatClass";
-export interface DistributionDTO extends DCAT_MODEL_DTO {
+import PROFILE_MODEL, { PROFILE_MODEL_DTO } from "../profileModel";
+export interface DistributionDTO extends PROFILE_MODEL_DTO {
     AccessServiceID?: string;
     AccessURL?: string;
     ByteSize?: number;
@@ -21,7 +21,7 @@ export interface DistributionDTO extends DCAT_MODEL_DTO {
     Checksum?: string;
     IsDistributionOf?: string;
 }
-declare class Distribution extends DCAT_MODEL {
+declare class Distribution extends PROFILE_MODEL {
     static UPLOAD_API_URL: string;
     static DOWNLOAD_API_URL: string;
     private UploadingData;
@@ -51,7 +51,7 @@ declare class Distribution extends DCAT_MODEL {
      */
     populateToSync(source: Distribution): void;
     toDTO(): DistributionDTO;
-    populateFromDTO(dto: DCAT_MODEL_DTO): Promise<void>;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
     /**
      * Initializes or updates the API URLs for the Distribution class.
      *

package/dist/SODAS_SDK_CLASS/profileModel.d.ts

@@ -0,0 +1,38 @@
+import { IDType, PaginatedResponse, SortOrder } from "../core/type";
+import SODAS_SDK_CLASS from "./sodasSDKClass";
+interface PROFILE_MODEL_STATIC<GENERIC> {
+    new (): GENERIC;
+    listDBRecords: typeof PROFILE_MODEL.listDBRecords;
+}
+export interface PROFILE_MODEL_DTO {
+    ID?: string;
+    IRI?: string;
+    Issued?: string;
+    Modified?: string;
+    CreatedAt?: string;
+    UpdatedAt?: string;
+}
+declare abstract class PROFILE_MODEL extends SODAS_SDK_CLASS {
+    protected CreatedAt: Date;
+    protected UpdatedAt: Date;
+    toDTO(): PROFILE_MODEL_DTO;
+    hasDBRecord(): boolean;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
+    static listDBRecords<GENERIC_PROFILE_MODEL extends PROFILE_MODEL>(this: PROFILE_MODEL_STATIC<GENERIC_PROFILE_MODEL>, pageNumber?: number, pageSize?: number, sortOrder?: SortOrder): Promise<PaginatedResponse<GENERIC_PROFILE_MODEL>>;
+    static getAllDBRecords<GENERIC_PROFILE_MODEL extends PROFILE_MODEL>(this: PROFILE_MODEL_STATIC<GENERIC_PROFILE_MODEL>): Promise<GENERIC_PROFILE_MODEL[]>;
+    createDBRecord(): Promise<void>;
+    static getDBRecord<GENERIC_PROFILE_MODEL extends PROFILE_MODEL>(this: PROFILE_MODEL_STATIC<GENERIC_PROFILE_MODEL>, ID: IDType): Promise<GENERIC_PROFILE_MODEL>;
+    static getDBRecordByAssetID<GENERIC_PROFILE_MODEL extends PROFILE_MODEL>(this: PROFILE_MODEL_STATIC<GENERIC_PROFILE_MODEL>, assetID: IDType): Promise<GENERIC_PROFILE_MODEL>;
+    /**
+     * Checks whether a DB record exists for the given AssetID and returns its ID.
+     *
+     * This method wraps getDBRecordByAssetID and converts a 404 response to `null`,
+     * while rethrowing any other kind of error.
+     */
+    static checkDBRecordOfAssetID(assetID: IDType): Promise<IDType | null>;
+    updateDBRecord(): Promise<void>;
+    deleteDBRecord(): Promise<void>;
+    get createdAt(): Date;
+    get updatedAt(): Date;
+}
+export default PROFILE_MODEL;

package/dist/SODAS_SDK_CLASS/template/validation.d.ts

@@ -1,59 +1,17 @@
-import { IDType, PaginatedResponse, SortOrder } from "../../core/type";
-import GOVERNANCE_MODEL, { GOVERNANCE_MODEL_DTO } from "../governanceClass";
-export declare enum VALIDATION_TYPE {
-    DATA_TYPE = "data_type",
-    RANGE = "range",
-    PATTERN = "pattern",
-    UNIQUENESS = "uniqueness",
-    COMPLETENESS = "completeness",
-    LENGTH = "length",
-    ALLOWED_VALUES = "allowed_values",
-    OUTLIER = "outlier",
-    STATISTICAL = "statistical"
-}
-export declare enum EXPECTED_TYPE {
-    NUMERIC = "numeric",
-    STRING = "string",
-    DATETIME = "datetime"
-}
-export interface ValidationRule {
-    column: string;
-    name: string;
-    type: VALIDATION_TYPE;
-}
-export interface completnessValidationRule extends ValidationRule {
-    type: VALIDATION_TYPE.COMPLETENESS;
-    min_completeness: number;
-    weight: number;
-}
-export interface dataTypeValidationRule extends ValidationRule {
-    type: VALIDATION_TYPE.DATA_TYPE;
-    expected_type: EXPECTED_TYPE;
-    weight: number;
-}
-export interface uniquenessValidationRule extends ValidationRule {
-    type: VALIDATION_TYPE.UNIQUENESS;
-    weight: number;
-}
-export interface patternValidationRule extends ValidationRule {
-    type: VALIDATION_TYPE.PATTERN;
-    pattern: string;
-    weight: number;
-}
-export interface ValidationTemplateDTO extends GOVERNANCE_MODEL_DTO {
-    name: string;
-    description?: string;
-    validationRules: ValidationRule[];
-}
-declare class ValidationTemplate extends GOVERNANCE_MODEL {
+import PROFILE_MODEL, { PROFILE_MODEL_DTO } from "../profileModel";
+import { AllowedValuesValidationRule, CompletenessValidationRule, CustomValidationRule, DataTypeValidationRule, LengthValidationRule, OutlierValidationRule, PatternValidationRule, RangeValidationRule, StatisticalValidationRule, UniquenessValidationRule, VALIDATION_TYPE, ValidationRule, ValidationRuleDTO } from "./validationType";
+export interface ValidationTemplateDTO extends PROFILE_MODEL_DTO {
+    Name?: string;
+    Description?: string;
+    ValidationRules?: ValidationRuleDTO[];
+}
+declare class ValidationTemplate extends PROFILE_MODEL {
     private Name;
     private Description;
     private ValidationRules;
     static configureAPIURL(url: string): void;
     toDTO(): ValidationTemplateDTO;
-    populateFromFormData(data: any): Promise<void>;
-    populateFromDTO(dto: GOVERNANCE_MODEL_DTO): Promise<void>;
-    static listDBRecords(pageNumber?: number, pageSize?: number, sortOrder?: SortOrder, vocabularyID?: IDType): Promise<PaginatedResponse<ValidationTemplate>>;
+    populateFromDTO(dto: PROFILE_MODEL_DTO): Promise<void>;
     get name(): string;
     set name(value: string);
     get description(): string;
@@ -62,9 +20,27 @@ declare class ValidationTemplate extends GOVERNANCE_MODEL {
     set validationRules(value: ValidationRule[]);
     static parseValidationRules(rawRules: any[]): ValidationRule[];
     private ensureValidationRulesInitialized;
-    createRule(type: VALIDATION_TYPE): ValidationRule;
-    deleteRuleAt(index: number): void;
-    deleteRuleByTypeAt(type: VALIDATION_TYPE, index: number): void;
+    createRangeRule(): RangeValidationRule;
+    createPatternRule(): PatternValidationRule;
+    createCompletenessRule(): CompletenessValidationRule;
+    createDataTypeRule(): DataTypeValidationRule;
+    createUniquenessRule(): UniquenessValidationRule;
+    createCustomRule(): CustomValidationRule;
+    createLengthRule(): LengthValidationRule;
+    createAllowedValuesRule(): AllowedValuesValidationRule;
+    createOutlierRule(): OutlierValidationRule;
+    createStatisticalRule(): StatisticalValidationRule;
+    getRangeRules(): RangeValidationRule[];
+    getPatternRules(): PatternValidationRule[];
+    getCompletenessRules(): CompletenessValidationRule[];
+    getDataTypeRules(): DataTypeValidationRule[];
+    getUniquenessRules(): UniquenessValidationRule[];
+    getCustomRules(): CustomValidationRule[];
+    getLengthRules(): LengthValidationRule[];
+    getAllowedValuesRules(): AllowedValuesValidationRule[];
+    getOutlierRules(): OutlierValidationRule[];
+    getStatisticalRules(): StatisticalValidationRule[];
+    deleteRule(rule: ValidationRule): void;
     static groupValidationRulesByColumn(rules: ValidationRule[]): Record<string, ValidationRule[]>;
     static groupValidationRulesByType(rules: ValidationRule[]): Record<VALIDATION_TYPE, ValidationRule[]>;
     /**
@@ -79,6 +55,5 @@ declare class ValidationTemplate extends GOVERNANCE_MODEL {
      * @returns Escaped JSON string with format: "{\"validation_rules\":[...]}"
      */
     static stringifyValidationRulesToEscapedString(rules: ValidationRule[]): string;
-    get rules(): ValidationRule[];
 }
 export default ValidationTemplate;

package/dist/SODAS_SDK_CLASS/template/validationType.d.ts

@@ -0,0 +1,196 @@
+export declare enum VALIDATION_TYPE {
+    DATA_TYPE = "data_type",
+    RANGE = "range",
+    PATTERN = "pattern",
+    UNIQUENESS = "uniqueness",
+    CUSTOM = "custom",
+    COMPLETENESS = "completeness",
+    LENGTH = "length",
+    ALLOWED_VALUES = "allowed_values",
+    OUTLIER = "outlier",
+    STATISTICAL = "statistical"
+}
+export declare enum EXPECTED_TYPE {
+    NUMERIC = "numeric",
+    STRING = "string",
+    DATETIME = "datetime"
+}
+export interface ValidationRuleDTO {
+    column: string;
+    name: string;
+    type: VALIDATION_TYPE;
+    weight: number;
+}
+export declare abstract class ValidationRule {
+    protected column: string;
+    protected name: string;
+    protected type: VALIDATION_TYPE;
+    protected weight: number;
+    constructor(type: VALIDATION_TYPE);
+    toDTO(): ValidationRuleDTO;
+    populateFromDTO(dto: any): void;
+    setColumn(column: string): this;
+    setName(name: string): this;
+    setWeight(weight: number): this;
+    get getColumn(): string;
+    get getName(): string;
+    get getType(): VALIDATION_TYPE;
+    get getWeight(): number;
+}
+export declare class UniquenessValidationRule extends ValidationRule {
+    protected unique: boolean;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        unique: boolean;
+    };
+    populateFromDTO(dto: any): void;
+    setUnique(unique: boolean): this;
+    get getUnique(): boolean;
+}
+export declare class PatternValidationRule extends ValidationRule {
+    protected pattern: string;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        pattern: string;
+    };
+    populateFromDTO(dto: any): void;
+    setPattern(pattern: string): this;
+    get getPattern(): string;
+}
+export declare class RangeValidationRule extends ValidationRule {
+    protected min_value: number;
+    protected max_value: number;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        min_value: number;
+        max_value: number;
+    };
+    populateFromDTO(dto: any): void;
+    setMinValue(minValue: number): this;
+    setMaxValue(maxValue: number): this;
+    get getMinValue(): number;
+    get getMaxValue(): number;
+}
+export declare enum COMPARISION_OPERATOR {
+    EQUAL = "==",
+    NOT_EQUAL = "!=",
+    GREATER_THAN = ">",
+    LESS_THAN = "<",
+    GREATER_THAN_OR_EQUAL = ">=",
+    LESS_THAN_OR_EQUAL = "<="
+}
+export declare enum CUSTOM_CONDITION_TYPE {
+    ALL = "all",
+    ANY = "any",
+    MIN = "min",
+    MAX = "max",
+    MEAN = "mean",
+    RATIO = "ratio"
+}
+export interface CUSTOM_CONDITION {
+    type: CUSTOM_CONDITION_TYPE;
+    threholder: number;
+    comparision: COMPARISION_OPERATOR;
+}
+export declare class CustomValidationRule extends ValidationRule {
+    protected condition: CUSTOM_CONDITION;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        condition: CUSTOM_CONDITION;
+    };
+    populateFromDTO(dto: any): void;
+    setCondition(condition: CUSTOM_CONDITION): this;
+    get getCondition(): CUSTOM_CONDITION;
+}
+export declare class LengthValidationRule extends ValidationRule {
+    protected min_length: number;
+    protected max_length: number;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        min_length: number;
+        max_length: number;
+    };
+    populateFromDTO(dto: any): void;
+    setMinLength(minLength: number): this;
+    setMaxLength(maxLength: number): this;
+    get getMinLength(): number;
+    get getMaxLength(): number;
+}
+export declare class AllowedValuesValidationRule extends ValidationRule {
+    protected allowed_values: string[];
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        allowed_values: string[];
+    };
+    populateFromDTO(dto: any): void;
+    setAllowedValues(allowedValues: string[]): this;
+    get getAllowedValues(): string[];
+}
+export declare enum OUTLIER_METHOD {
+    Z_SCORE = "zscore",
+    IQR = "iqr",
+    ISOLATION = "isolation"
+}
+export declare class OutlierValidationRule extends ValidationRule {
+    protected method: OUTLIER_METHOD;
+    protected threshold: number;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        method: OUTLIER_METHOD;
+        threshold: number;
+    };
+    populateFromDTO(dto: any): void;
+    setMethod(method: OUTLIER_METHOD): this;
+    setThreshold(threshold: number): this;
+    get getMethod(): OUTLIER_METHOD;
+    get getThreshold(): number;
+}
+export declare class StatisticalValidationRule extends ValidationRule {
+    protected check: string;
+    protected threshold: number;
+    protected comparision: COMPARISION_OPERATOR;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        check: string;
+        threshold: number;
+        comparision: COMPARISION_OPERATOR;
+    };
+    populateFromDTO(dto: any): void;
+    setCheck(check: string): this;
+    setThreshold(threshold: number): this;
+    setComparision(comparision: COMPARISION_OPERATOR): this;
+    get getCheck(): string;
+    get getThreshold(): number;
+    get getComparision(): COMPARISION_OPERATOR;
+}
+export declare class CompletenessValidationRule extends ValidationRule {
+    protected min_completeness: number;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        min_completeness: number;
+    };
+    populateFromDTO(dto: any): void;
+    setMinCompleteness(minCompleteness: number): this;
+    get getMinCompleteness(): number;
+}
+export declare enum DATETIME_FORMAT_TYPE {
+    YYYY_MM_DD_HH_MM_SS = "%Y-%m-%d %H:%M:%S",
+    YYYY_MM_DD = "%Y-%m-%d",
+    YYYY_MM_DD_SLASH = "%Y/%m/%d",
+    DD_MM_YYYY = "%d-%m-%Y",
+    YYYY_MM_DD_T_HH_MM_SS = "%Y-%m-%dT%H:%M:%S"
+}
+export declare class DataTypeValidationRule extends ValidationRule {
+    protected expected_type: EXPECTED_TYPE;
+    protected datetime_format: DATETIME_FORMAT_TYPE;
+    constructor();
+    toDTO(): ValidationRuleDTO & {
+        expected_type: EXPECTED_TYPE;
+        datetime_format: DATETIME_FORMAT_TYPE;
+    };
+    populateFromDTO(dto: any): void;
+    setExpectedType(expectedType: EXPECTED_TYPE): this;
+    setDatetimeFormat(datetimeFormat: DATETIME_FORMAT_TYPE): this;
+    get getExpectedType(): EXPECTED_TYPE;
+    get getDatetimeFormat(): DATETIME_FORMAT_TYPE;
+}

package/dist/__tests__/setting/testEnvironmentConfig.d.ts

@@ -1,4 +1,4 @@
 export declare const TEST_SODAS_PROFILE_API_URL: string;
-export declare const TEST_GOVERNANCE_API_URL: string;
 export declare const TEST_LEGACY_DATAHUB_API_URL: string;
+export declare const TEST_GOVERNANCE_API_URL: string;
 export declare function setBearerTokenForTest(): Promise<void>;

package/dist/__tests__/setting/testSetting.d.ts

@@ -1,2 +1,2 @@
 export declare function settingSDKForTest(): Promise<void>;
-export declare function getTestCasesWithNullFields<GENERIC_DCAT_MODEL>(mock: GENERIC_DCAT_MODEL): GENERIC_DCAT_MODEL[];
+export declare function getTestCasesWithNullFields<GENERIC_PROFILE_MODEL>(mock: GENERIC_PROFILE_MODEL): GENERIC_PROFILE_MODEL[];

package/dist/__tests__/utility/BOC.d.ts

@@ -1,5 +1,5 @@
-import DCAT_MODEL from "../../SODAS_SDK_CLASS/dcatClass";
 import GOVERNANCE_MODEL from "../../SODAS_SDK_CLASS/governanceClass";
+import PROFILE_MODEL from "../../SODAS_SDK_CLASS/profileModel";
 import SODAS_SDK_CLASS from "../../SODAS_SDK_CLASS/sodasSDKClass";
 import { PaginatedResponse, SortOrder } from "../../core/type";
 export declare function compareAllFieldsExcept<GENERIC_SODAS_SDK_CLASS>(exceptingFields: string[], result: GENERIC_SODAS_SDK_CLASS, expected: GENERIC_SODAS_SDK_CLASS): void;
@@ -7,9 +7,9 @@ export declare function checkFieldsCreationByAPI<GENERIC_SODAS_SDK_CLASS>(create
 export declare function checkFieldsPreservedByUpdate<GENERIC_SODAS_SDK_CLASS>(updated: GENERIC_SODAS_SDK_CLASS, created: GENERIC_SODAS_SDK_CLASS): void;
 export declare function checkUpdatedAtField(updatedAtofUpdated: Date, updatedAtofCreated: Date): void;
 export declare function checkCantDeleteAlreadyRecordRemovedInstance(recordRemovedInstance: SODAS_SDK_CLASS): Promise<void>;
-export declare function testListInOrderAndTotal<GENERIC_DCAT_MODEL extends DCAT_MODEL>(TOTAL: number, BATCH_SIZE: number, createFn: (number: number) => Promise<GENERIC_DCAT_MODEL[]>, Class: {
-    new (): GENERIC_DCAT_MODEL;
-    listDBRecords: (pageNumber: number, pageSize: number, sortOrder: SortOrder) => Promise<PaginatedResponse<GENERIC_DCAT_MODEL>>;
+export declare function testListInOrderAndTotal<GENERIC_PROFILE_MODEL extends PROFILE_MODEL>(TOTAL: number, BATCH_SIZE: number, createFn: (number: number) => Promise<GENERIC_PROFILE_MODEL[]>, Class: {
+    new (): GENERIC_PROFILE_MODEL;
+    listDBRecords: (pageNumber: number, pageSize: number, sortOrder: SortOrder) => Promise<PaginatedResponse<GENERIC_PROFILE_MODEL>>;
 }): Promise<void>;
 interface ListableModelClass {
     listDBRecords(pageNumber: number, pageSize: number, sortOrder: SortOrder, firstArgument?: any, secondArgument?: any): Promise<PaginatedResponse<GOVERNANCE_MODEL>>;

package/dist/__tests__/utility/testDTO.d.ts

@@ -1,6 +1,7 @@
 import { DataServiceDTO } from "../../SODAS_SDK_CLASS/DCAT/dataService";
 import { DatasetDTO } from "../../SODAS_SDK_CLASS/DCAT/dataset";
 import { DistributionDTO } from "../../SODAS_SDK_CLASS/DCAT/distribution";
+import { ValidationTemplateDTO } from "../../SODAS_SDK_CLASS/template/validation";
 export declare const FullTestCreateDataServiceDTO: DataServiceDTO;
 export declare const FullTestUpdateDataServiceDTO: DataServiceDTO;
 export declare const FullTestCreateDatasetDTO: DatasetDTO;
@@ -9,3 +10,5 @@ export declare const FullTestCreateDatasetSeriesDTO: DatasetDTO;
 export declare const FullTestUpdateDatasetSeriesDTO: DatasetDTO;
 export declare const FullTestCreateDistributionDTO: DistributionDTO;
 export declare const FullTestUpdateDistributionDTO: DistributionDTO;
+export declare const FullTestCreateValidationTemplateDTO: ValidationTemplateDTO;
+export declare const FullTestUpdateValidationTemplateDTO: ValidationTemplateDTO;

package/dist/__tests__/utility/validation.d.ts

@@ -1,6 +1,4 @@
-import ValidationTemplate, { ValidationTemplateDTO } from "../../SODAS_SDK_CLASS/template/validation";
-export declare function getTestCreateValidationTemplateDTO(index?: number, name?: string): ValidationTemplateDTO;
-export declare function getTestUpdateValidationTemplateDTO(updating: ValidationTemplate, index?: number): ValidationTemplateDTO;
-export declare function createTestValidationTemplate(index?: number, name?: string): Promise<ValidationTemplate>;
-export declare function createNumberOfTestValidationTemplates(number?: number, name?: string): Promise<ValidationTemplate[]>;
+import ValidationTemplate from "../../SODAS_SDK_CLASS/template/validation";
+export declare function createTestValidationTemplate(): Promise<ValidationTemplate>;
+export declare function createNumberOfTestValidationTemplates(number?: number): Promise<ValidationTemplate[]>;
 export declare function deleteAllValidationTemplates(): Promise<void>;

package/dist/core/auth.d.ts

@@ -10,7 +10,7 @@ declare class Config {
      * Explicitly configure the SDK with the given API URLs.
      * This is the preferred way to set API URLs instead of using configureAPIURL.
      */
-    static configure(datahubApiUrl: string, governanceApiUrl: string, legacyDatahubApiUrl: string): Config;
+    static configure(datahubApiUrl: string, legacyDatahubApiUrl: string, governanceApiUrl: string): Config;
     /**
      * Get the singleton instance of Config, using environment variables.
      */

package/dist/core/error.d.ts

@@ -1,5 +1,4 @@
 import SODAS_SDK_CLASS from "../SODAS_SDK_CLASS/sodasSDKClass";
-import { ResourceDescriptorRole } from "./type";
 export declare class AlreadyRecordedError extends Error {
     constructor(instance: SODAS_SDK_CLASS);
 }
@@ -51,12 +50,6 @@ export declare class RecordNotFoundError extends Error {
 export declare class RequirementsNotSetError extends Error {
     constructor();
 }
-export declare class ResourceRoleDescriptorAlreadyExist extends Error {
-    constructor(role: ResourceDescriptorRole);
-}
-export declare class ResourceRoleDescriptorNotExist extends Error {
-    constructor(role: ResourceDescriptorRole);
-}
 export declare class RetryLimitReachedError extends Error {
     constructor(max: number);
 }

package/dist/core/functionalityError.d.ts

@@ -1,11 +1,4 @@
-import { IRIType, TemplateDetailFunctionality } from "./type";
-/***********************COMMON ERROR***********************/
-export declare class NotValidResourceDescsriptor extends Error {
-    constructor();
-}
-export declare class NotEnoughFuntionalityTemplate extends Error {
-    constructor(requiredFuncionalityList: TemplateDetailFunctionality[], inputFunctionalityList: TemplateDetailFunctionality[]);
-}
+import { IRIType } from "./type";
 /***********************TYPE ERROR***********************/
 export declare class DuplicatedTypeLabel extends Error {
     constructor(label: string);

package/dist/core/type.d.ts

@@ -29,10 +29,6 @@ export declare function toDateString(date: Date | null): DateString;
  * @returns {Date} - The corresponding JavaScript Date object.
  */
 export declare function toDate(dateString: DateString): Date;
-export type TemplateArtifactRow = {
-    [K in TemplateDetailFunctionality]?: any;
-};
-export type TemplateArtifactValue = Array<TemplateArtifactRow>;
 /**
  * Represents a multilingual field where each key is a language code (e.g., "en", "ko") and the value is a string.
  */
@@ -48,39 +44,9 @@ export type MultiLanguageKeywords = {
 export type ExtraMetadataType = {
     [MetaFieldName: string]: string;
 };
-export declare enum ResourceDescriptorRole {
-    VOCABULARY = "vocabulary",
-    TYPE = "type",
-    SCHEMA = "schema",
-    CONSTRAINT = "constraint",
-    VALIDATION = "validation",
-    MAPPING = "mapping",
-    EXAMPLE = "example",
-    SPECIFICATION = "specification",
-    GUIDANCE = "guidance"
-}
-export declare enum ArtifactType {
-    TEMPLATE = "template",
-    FILE = "file"
-}
-export declare enum TemplateDetailFunctionality {
-    ORIGIN = "origin",
-    NAMESPACE = "namespaceIRI",
-    TERM = "term",
-    DESCRIPTION = "description",//EXAMPLE and SCHEMA ALSO
-    NAME = "name",//SCHEMA ALSO
-    LABEL = "label",
-    VALUE = "value",//EXAMPLE ALSO
-    TYPE = "type",//CONSTRAINT ALSO
-    REQUIRED = "required",//CONSTRAINT ALSO
-    FIELD_TERM = "fieldTerm",
-    FIELD = "field",//EXAMPLE and MAPPING ALSO
-    REGEX = "regex",
-    MEASURE = "measure",
-    TARGET_PROFILE = "targetProfile",
-    TARGET_FIELD = "targetField",
-    CONVERSION = "conversion"
-}
+export type QualityMetadataType = {
+    [QualityMetadataFieldName: string]: string;
+};
 export type PaginatedResponse<GENERIC_SODAS_SDK_CLASS> = {
     total: number;
     list: GENERIC_SODAS_SDK_CLASS[];