@ui5/task-adaptation 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -2,7 +2,10 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.3.1...HEAD).
+A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.3.2...HEAD).
+
+<a name="v1.3.2"></a>
+## [v1.3.2] - 2024-06-04
 
 <a name="v1.3.1"></a>
 ## [v1.3.1] - 2024-06-04
@@ -91,6 +94,7 @@ A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task
 <a name="v1.0.0"></a>
 ## v1.0.0 - 2020-12-09
 
+[v1.3.2]: https://github.com/SAP/ui5-task-adaptation/compare/v1.3.1...v1.3.2
 [v1.3.1]: https://github.com/SAP/ui5-task-adaptation/compare/v1.3.0...v1.3.1
 [v1.3.0]: https://github.com/SAP/ui5-task-adaptation/compare/v1.2.0...v1.3.0
 [v1.2.0]: https://github.com/SAP/ui5-task-adaptation/compare/v1.1.3...v1.2.0

package/dist/annotationManager.d.ts

@@ -0,0 +1,18 @@
+import AbapRepoManager from "./repositories/abapRepoManager.js";
+import { IConfiguration } from "./model/types.js";
+import Language from "./model/language.js";
+export interface IAnnotationFiles {
+    annotationName: string;
+    annotationFileName: string;
+}
+export default class AnnotationManager {
+    private abapRepoManager;
+    private configuration;
+    constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager);
+    ANNOTATIONS_FOLDER: string;
+    process(renamedBaseAppManifest: any, languages: Language[]): Promise<Map<string, string>>;
+    private normalizeAppVariantId;
+    private updateManifestModel;
+    private createManifestModel;
+    private enhanceManifestModel;
+}

package/dist/annotationManager.js

@@ -0,0 +1,79 @@
+import BaseAppManager from "./baseAppManager.js";
+import DataSourceManager from "./annotations/dataSource/dataSourceManager.js";
+import I18nManager from "./i18nManager.js";
+import ServiceRequestor from "./annotations/serviceRequestor.js";
+import { posix as path } from "path";
+const I18N_DEFAULT_PATH = "i18n/annotations";
+const I18N_DEFAULT_MODEL_NAME = "@i18n";
+const SAPUI5 = "sap.ui5";
+export default class AnnotationManager {
+    abapRepoManager;
+    configuration;
+    constructor(configuration, abapRepoManager) {
+        this.configuration = configuration;
+        this.abapRepoManager = abapRepoManager;
+    }
+    ANNOTATIONS_FOLDER = "annotations";
+    async process(renamedBaseAppManifest, languages) {
+        const { id } = BaseAppManager.getIdVersion(renamedBaseAppManifest);
+        BaseAppManager.validateProperty(id, "sap.app/id");
+        const normalisedId = this.normalizeAppVariantId(id);
+        //TODO: switch to this after resolving @i18n custom model
+        const modelName = I18N_DEFAULT_MODEL_NAME; //`i18n_a9n_${normalisedId}`;
+        const i18nPathName = path.join(I18N_DEFAULT_PATH, normalisedId);
+        const i18nManager = new I18nManager(modelName, id, languages);
+        const serviceRequestor = new ServiceRequestor(this.configuration, this.abapRepoManager);
+        const dataSourceManager = new DataSourceManager();
+        dataSourceManager.addDataSources(renamedBaseAppManifest["sap.app"]?.dataSources);
+        const annotationFiles = await dataSourceManager.createAnnotationFiles(languages, i18nManager, serviceRequestor);
+        const i18nFiles = i18nManager.createFiles(i18nPathName);
+        if (i18nManager.hasTranslations()) {
+            this.updateManifestModel(renamedBaseAppManifest, modelName, i18nPathName);
+        }
+        return new Map([...annotationFiles, ...i18nFiles]);
+    }
+    normalizeAppVariantId(id, replaceWith = "") {
+        return id.replace(/[.\W]+/gi, replaceWith);
+    }
+    updateManifestModel(renamedBaseAppManifest, modelName, i18nPathName) {
+        const uri = `${i18nPathName}/i18n.properties`;
+        this.enhanceManifestModel(renamedBaseAppManifest, modelName, uri);
+        //TODO: switch to this after resolving @i18n custom model
+        //this.createManifestModel(renamedBaseAppManifest, modelName, uri);
+    }
+    createManifestModel(manifest, modelName, uri) {
+        let sapui5 = manifest[SAPUI5] == null ? manifest[SAPUI5] = {} : manifest[SAPUI5];
+        if (sapui5.models == null) {
+            sapui5.models = {};
+        }
+        if (sapui5.models[modelName] == null) {
+            sapui5.models[modelName] = {};
+        }
+        sapui5.models[modelName].type = "sap.ui.model.resource.ResourceModel";
+        if (uri) {
+            sapui5.models[modelName].uri = uri;
+        }
+        return sapui5.models[modelName];
+    }
+    enhanceManifestModel(manifest, modelToEnhance, bundleUrl) {
+        let model = manifest[SAPUI5]?.models[modelToEnhance];
+        if (model) {
+            if (model.settings == null) {
+                model.settings = {};
+            }
+            if (model.settings.enhanceWith == null) {
+                model.settings.enhanceWith = [];
+            }
+            if (model.settings.enhanceWith.every((bundle) => bundle.bundleUrl !== bundleUrl)) {
+                model.settings.enhanceWith.push({
+                    bundleUrl,
+                    bundleUrlRelativeTo: "component"
+                });
+            }
+        }
+        else {
+            this.createManifestModel(manifest, modelToEnhance, bundleUrl);
+        }
+    }
+}
+//# sourceMappingURL=annotationManager.js.map

package/dist/annotations/comparator/comparator.d.ts

@@ -0,0 +1,47 @@
+export interface IDiffProperty {
+    object: any;
+    property: string | number;
+}
+export declare class Diff {
+    __old: string;
+    __new: string;
+    constructor(__old: string, __new: string);
+    toString(): string;
+}
+export interface DiffJson {
+    json: any;
+    properties: Set<IDiffProperty>;
+}
+export default class Comparator {
+    private diffs;
+    private xml_a;
+    private xml_b;
+    constructor(xml_a: string, xml_b: string);
+    compare(): DiffJson;
+    private traverseCompare;
+    /**
+     * If one language annotation has one property it is an object, if other
+     * language same annotation consists of multiple properties, we need to
+     * equal them, so they are both arrays (see test 01-04).
+     */
+    private arrayIfNeeded;
+    /**
+     * If some node (Annotations, Annotation, PropertyValue, LabeledElement) has
+     * an id, we can compare by id, so the items order doesn't matter anymore.
+     * @param a array of nodes with id of one language
+     * @param b array of nodes with id of the other language
+     * @param idProperty property which value is an id (e.g. Target="<unique-id>")
+     * @param property node name (Annotations, Annotation, PropertyValue, ...)
+     */
+    private traverseById;
+    /**
+     *  Some nodes, like Annotations, Annotation, PropertyValue have unique id
+     *  among other same nodes. We can use it to know what to compare with what
+     *  even if the order is different. IdProperty is a property name of that id,
+     *  e.g. for Annotations it will be Target (like in
+     *  Target="<some-unique-id>").
+     *  @param property node which might have an id: Annotations, PropertyValue
+     *  @return the property name which represents id: Target, Property
+     */
+    private getIdProperty;
+}

package/dist/annotations/comparator/comparator.js

@@ -0,0 +1,283 @@
+import { insertInArray, traverse } from "../../util/commonUtil.js";
+import AnnotationDiffStructureError from "../../model/annotationDiffStructureError.js";
+import InterchangableCase from "./interchangableCase.js";
+import MetadataJsonUtil from "../converter/metadataJsonUtil.js";
+import XmlUtil from "../../util/xmlUtil.js";
+export class Diff {
+    __old;
+    __new;
+    constructor(__old, __new) {
+        this.__old = __old;
+        this.__new = __new;
+    }
+    toString() {
+        return `{ __old: ${this.__old},  __new: ${this.__new} }`;
+    }
+}
+export default class Comparator {
+    diffs = new Set();
+    xml_a;
+    xml_b;
+    constructor(xml_a, xml_b) {
+        this.xml_a = xml_a;
+        this.xml_b = xml_b;
+    }
+    compare() {
+        const json_a = typeof this.xml_a === "string" ? XmlUtil.xmlToJson(this.xml_a) : this.xml_a;
+        const json_b = typeof this.xml_b === "string" ? XmlUtil.xmlToJson(this.xml_b) : this.xml_b;
+        const scheme_a = MetadataJsonUtil.getSchemaNode(json_a);
+        const scheme_b = MetadataJsonUtil.getSchemaNode(json_b);
+        if (scheme_a && scheme_b) {
+            // we compare only Annotations, other types are left as it is
+            this.traverseCompare(scheme_a, scheme_b, "Annotations");
+        }
+        return {
+            json: json_a,
+            properties: this.diffs
+        };
+    }
+    traverseCompare(obj_a, obj_b, property) {
+        let a = obj_a[property];
+        let b = obj_b[property];
+        if (typeof a === "object" && !(a instanceof Diff) && typeof b !== "object" ||
+            typeof b === "object" && !(b instanceof Diff) && typeof a !== "object" ||
+            a == null || b == null) {
+            // When during traversing we end up in primitives like string, we
+            // compare the values. If one of them is not primitive or oone of
+            // them is undefined, we throw exception (see test 06, 07).
+            throw new AnnotationDiffStructureError({ a, b });
+        }
+        else if (typeof a !== "object" && typeof b !== "object") {
+            // If primitive values are not same - we assume they are
+            // translations, so we save them.
+            if (a !== b) {
+                obj_a[property] = new Diff(a, b);
+                this.diffs.add({ object: obj_a, property });
+            }
+        }
+        else {
+            a = this.arrayIfNeeded(obj_a, obj_b, property);
+            b = this.arrayIfNeeded(obj_b, obj_a, property);
+            if (Array.isArray(a)) {
+                let idProperty = this.getIdProperty(property);
+                if (idProperty) {
+                    this.traverseById(a, b, idProperty, property);
+                }
+                else {
+                    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+                        if (a[i] && b[i]) {
+                            this.traverseCompare(a, b, i);
+                        }
+                        else {
+                            // If the number of items of nodes without id are
+                            // different, we throw error (see test 08).
+                            throw new AnnotationDiffStructureError({ a, b });
+                        }
+                    }
+                }
+            }
+            else {
+                for (const key of Object.keys(a)) {
+                    this.traverseCompare(a, b, key);
+                }
+            }
+        }
+    }
+    /**
+     * If one language annotation has one property it is an object, if other
+     * language same annotation consists of multiple properties, we need to
+     * equal them, so they are both arrays (see test 01-04).
+     */
+    arrayIfNeeded(obj_a, obj_b, property) {
+        if (!Array.isArray(obj_a[property])) {
+            // If node with id - make array anyway, so it's easier to compare (see test 04).
+            if (simpleIdentifiers.has(property) || Array.isArray(obj_b[property])) {
+                obj_a[property] = [obj_a[property]];
+            }
+        }
+        return obj_a[property];
+    }
+    /**
+     * If some node (Annotations, Annotation, PropertyValue, LabeledElement) has
+     * an id, we can compare by id, so the items order doesn't matter anymore.
+     * @param a array of nodes with id of one language
+     * @param b array of nodes with id of the other language
+     * @param idProperty property which value is an id (e.g. Target="<unique-id>")
+     * @param property node name (Annotations, Annotation, PropertyValue, ...)
+     */
+    traverseById(a, b, idProperty, property) {
+        if (typeof property !== "string") {
+            return;
+        }
+        let items_a = new Items(a, idProperty);
+        let items_b = new Items(b, idProperty);
+        const includer_a = new Includer(a, property);
+        const includer_b = new Includer(b, property);
+        for (let i = 0; i < Math.max(a.length, b.length); i++) {
+            // There might be an exceptional case, when the object doesn't
+            // contain attributes. In this case we continue traversing, like
+            // UI5 does.
+            const id_a = a[i]?._attributes?.[idProperty];
+            const id_b = b[i]?._attributes?.[idProperty];
+            if (id_a !== id_b) {
+                // We go down the array and if suddenly the ids for comparing
+                // items are not the same, we need to find the item with the
+                // same id if it exists.
+                if (items_b.has(id_a) && items_a.has(id_b)) {
+                    // If we found the item with the same id, we swap places
+                    // with current item (see test 05).
+                    items_b.swap(id_a, i);
+                }
+                else if (!items_a.has(id_b) && id_b) {
+                    // If 1st language missing the item, include it from 2nd (see test 02).
+                    includer_a.include(b, i);
+                }
+                else if (!items_b.has(id_a) && id_a) {
+                    // If 2nd language missing the item, include it from 1st (see test 03).
+                    includer_b.include(a, i);
+                }
+            }
+            this.traverseCompare(a, b, i);
+        }
+    }
+    /**
+     *  Some nodes, like Annotations, Annotation, PropertyValue have unique id
+     *  among other same nodes. We can use it to know what to compare with what
+     *  even if the order is different. IdProperty is a property name of that id,
+     *  e.g. for Annotations it will be Target (like in
+     *  Target="<some-unique-id>").
+     *  @param property node which might have an id: Annotations, PropertyValue
+     *  @return the property name which represents id: Target, Property
+     */
+    getIdProperty(property) {
+        return simpleIdentifiers.get(property);
+    }
+}
+class Includer {
+    ALL_DIFF_CASES = [
+        new InterchangableCase()
+    ];
+    diffCases = new Array();
+    shouldClear;
+    target;
+    property;
+    /**
+     * It will decide what to do with the item missing in one language.
+     * @param target an array which might miss the item
+     * @param property the node name needed to decide how to include the missing
+     * item in array
+     * @param shouldClear if the item is missing and it's not Label or QuickInfo
+     * or Heading, we clear all the properties except Ids, so in i18n.properties
+     * they will have empty values. Because we don't know what should be there.
+     */
+    constructor(target, property, shouldClear = true) {
+        this.shouldClear = shouldClear;
+        this.target = target;
+        this.property = property;
+        for (const diffCase of this.ALL_DIFF_CASES) {
+            if (diffCase.canAccept(target, property)) {
+                this.diffCases.push(diffCase);
+            }
+        }
+    }
+    /**
+     * If in some language some array missing the item, we include the missing
+     * item from other language array with the same id.
+     * @param source the item from other language array that is missed in target
+     * @param index here to put it in the array
+     */
+    include(source, index) {
+        // Insert node with empty value (see test 02) if missing in default
+        // language or default language value if missing in other language
+        // (see test 03).
+        const clone = Includer.cloneAndClear(source[index], this.shouldClear);
+        insertInArray(this.target, index, clone);
+        // Some annotations like Label, QuickInfo or Heading are
+        // interchangable so if QuickInfo is missing we can copy the value
+        // from Label or Heading (see test 01).
+        for (const diffCase of this.diffCases) {
+            diffCase.accept(this.target, index, this.property);
+        }
+    }
+    /**
+     * if the item is missing in default language, and it's not Label or
+     * QuickInfo or Heading, we clear all the properties except Ids, so in
+     * i18n.properties they will have empty values. Because we don't know what
+     * should be there. But if the item is missing in language other than
+     * default, we include the copy of item from default language and not
+     * clearing them (see test 02, 04).
+     */
+    static cloneAndClear(obj, shouldClear = true) {
+        const clone = structuredClone(obj);
+        if (shouldClear) {
+            traverse(clone, [], (json, key) => {
+                if (typeof key !== "string" || !simpleIdentifiersReversed.has(key)) {
+                    json[key] = "";
+                }
+            });
+        }
+        return clone;
+    }
+}
+class Items {
+    idProperty;
+    array;
+    objectMap = null;
+    /**
+     * Map of id per item which is lazy initialized if needed
+     * @param array
+     * @param idProperty
+     */
+    constructor(array, idProperty) {
+        this.array = array;
+        this.idProperty = idProperty;
+    }
+    /**
+     * Find the item with by id and swap their places.
+     * @param id of the item which seems like not in the place it should be
+     * @param newIndex new place where the item should actually be
+     */
+    swap(id, newIndex) {
+        const oldIndex = this.initMap().get(id);
+        const temp = this.array[newIndex];
+        this.array[newIndex] = this.array[oldIndex];
+        this.array[oldIndex] = temp;
+        this.initMap(true);
+    }
+    has(idProperty) {
+        return this.initMap().has(idProperty);
+    }
+    get(idProperty) {
+        return this.array[this.initMap().get(idProperty)];
+    }
+    /**
+     * Lazy init the map only if the order of items are messed up, which
+     * actually an eexception, so will make it lazy way.
+     * @param force force to update.
+     * @returns the map id per item index.
+     */
+    initMap(force = false) {
+        if (this.objectMap == null || force) {
+            this.objectMap = new Map(this.array.map((item, index) => [item._attributes[this.idProperty], index]));
+        }
+        return this.objectMap;
+    }
+}
+class Identifiers extends Map {
+    has(property) {
+        return typeof property === "string" && super.has(property);
+    }
+    get(property) {
+        return typeof property === "string" ? super.get(property) : undefined;
+    }
+}
+// According to OData schema some nodes MUST have the ids, by these nodes the
+// property which contains the id is named differently as you can see.
+const simpleIdentifiers = new Identifiers([
+    ["Annotations", "Target"],
+    ["Annotation", "Term"],
+    ["LabeledElement", "Name"],
+    ["PropertyValue", "Property"]
+]);
+const simpleIdentifiersReversed = new Identifiers([...simpleIdentifiers].map(([name, idProperty]) => [idProperty, name]));
+//# sourceMappingURL=comparator.js.map

package/dist/annotations/comparator/diffCase.d.ts

@@ -0,0 +1,4 @@
+export default interface DiffCase {
+    accept(target: any[], i: number, name?: string): void;
+    canAccept(target: any[], name?: string): boolean;
+}

package/dist/annotations/comparator/diffCase.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diffCase.js.map

package/dist/annotations/comparator/interchangableCase.d.ts

@@ -0,0 +1,25 @@
+import DiffCase from "./diffCase.js";
+export default class InterchangableCase implements DiffCase {
+    accept(target: any[], i: number, name: string): void;
+    /**
+     * When default language source is already compared, it contains diff, e.g.
+     * { __old: value, __new: wert 1 }, if target annotation in other language
+     * has other value, it should also reflect the value, be { __old: value,
+     * __new: wert 2 }, not { __old: value,  __new: wert 1 }. So we remove the
+     * diff completely from value and let it be compared again. Other language
+     * source will be empty anyway.
+     */
+    private getSourceValue;
+    /**
+     * If the array doesn't have any other annotations to take the values from,
+     * we just don't do it and include the annotations from other language as it
+     * is. E.g. we include Label but there are no Heading or QuickInfo to take
+     * values from. So we just don't do it.
+     * @param target where to put the missing item
+     * @param property node name
+     * @returns true if there are some annotations to take the values from.
+     */
+    canAccept(target: any[], property: string): boolean;
+    private interchangableTerms;
+    private findByPriority;
+}

package/dist/annotations/comparator/interchangableCase.js

@@ -0,0 +1,60 @@
+import { Diff } from "./comparator.js";
+export default class InterchangableCase {
+    accept(target, i, name) {
+        if (name === "Annotation" && this.interchangableTerms.includes(target[i]?._attributes?.Term)) {
+            const source = this.findByPriority(target, i);
+            if (source) {
+                for (const attribute of Object.keys(source._attributes)) {
+                    if (attribute !== "Term") {
+                        const sourceValue = this.getSourceValue(source, attribute);
+                        target[i]._attributes[attribute] = sourceValue;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * When default language source is already compared, it contains diff, e.g.
+     * { __old: value, __new: wert 1 }, if target annotation in other language
+     * has other value, it should also reflect the value, be { __old: value,
+     * __new: wert 2 }, not { __old: value,  __new: wert 1 }. So we remove the
+     * diff completely from value and let it be compared again. Other language
+     * source will be empty anyway.
+     */
+    getSourceValue(source, attribute) {
+        let value = source._attributes[attribute];
+        if (value instanceof Diff) {
+            value = value.__old;
+        }
+        return value;
+    }
+    /**
+     * If the array doesn't have any other annotations to take the values from,
+     * we just don't do it and include the annotations from other language as it
+     * is. E.g. we include Label but there are no Heading or QuickInfo to take
+     * values from. So we just don't do it.
+     * @param target where to put the missing item
+     * @param property node name
+     * @returns true if there are some annotations to take the values from.
+     */
+    canAccept(target, property) {
+        return property === "Annotation" && target
+            .map(item => item._attributes?.Term)
+            .some(term => this.interchangableTerms.includes(term));
+    }
+    // If one of the terms is missing, its values can be filled by others.
+    // Usually Heading or QuickInfo is missing. So we order terms by source
+    // priority (take from label first).
+    interchangableTerms = ["SAP__common.Label", "SAP__common.Heading", "SAP__common.QuickInfo"];
+    findByPriority(annotations, index) {
+        for (const interchangableTerm of this.interchangableTerms) {
+            for (const annotation of annotations) {
+                if (annotation._attributes?.Term === interchangableTerm &&
+                    annotation !== annotations[index]) {
+                    return annotation;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=interchangableCase.js.map

package/dist/annotations/converter/metadataJsonReferenceUtil.d.ts

@@ -0,0 +1,12 @@
+export default class MetadataJsonReferenceUtil {
+    private json;
+    private aliases;
+    private namespaces;
+    constructor(json: any);
+    aliasToNamespace(target: string): string;
+    namespaceToAlias(target: string): string;
+    private convertReference;
+    private getAliases;
+    private getNamespaces;
+    private initReferences;
+}

package/dist/annotations/converter/metadataJsonReferenceUtil.js

@@ -0,0 +1,48 @@
+import MetadataJsonUtil from "./metadataJsonUtil.js";
+export default class MetadataJsonReferenceUtil {
+    json;
+    aliases = null;
+    namespaces = null;
+    constructor(json) {
+        this.json = json;
+    }
+    aliasToNamespace(target) {
+        return this.convertReference(this.getAliases(), target);
+    }
+    namespaceToAlias(target) {
+        return this.convertReference(this.getNamespaces(), target);
+    }
+    convertReference(references, target) {
+        for (const alias of references.keys()) {
+            target = target.replaceAll(alias + ".", references.get(alias) + ".");
+        }
+        return target;
+    }
+    getAliases() {
+        this.initReferences();
+        return this.aliases;
+    }
+    getNamespaces() {
+        this.initReferences();
+        return this.namespaces;
+    }
+    initReferences() {
+        if (!this.aliases || !this.namespaces) {
+            const references = new Array();
+            for (const ref of MetadataJsonUtil.getReferences(this.json)) {
+                references.push(...ref.includes);
+            }
+            references.push(MetadataJsonUtil.getSchemaReference(this.json));
+            this.aliases = new Map();
+            this.namespaces = new Map();
+            for (const mapping of references) {
+                if (mapping.alias && mapping.namespace) {
+                    const { alias, namespace } = mapping;
+                    this.aliases.set(alias, namespace);
+                    this.namespaces.set(namespace, alias);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=metadataJsonReferenceUtil.js.map

package/dist/annotations/converter/metadataJsonUtil.d.ts

@@ -0,0 +1,30 @@
+export default class MetadataJsonUtil {
+    static mapAnnotationsPerTarget(json: any): Map<string, IJsonIndex>;
+    static getVersion(json: any): any;
+    static getAnnotations(json: any): any[];
+    static setAnnotations(json: any, annotations: any[]): void;
+    static getSchemaNode(json: any): any;
+    static getSchemaReference(json: any): MetadataInclude;
+    static getEdmx(json: any): any;
+    static getDataServices(json: any): any;
+    static getReferences(json: any): MetadataReference[];
+    static toArrayReadOnly(json: any): any[];
+    static toArrayTransform(json: any, property: string): void;
+}
+export declare class MetadataReference {
+    uri: string;
+    includes: MetadataInclude[];
+    constructor(referenceJson: any);
+    getAlias(namespace: string): string | undefined;
+}
+export declare class MetadataInclude {
+    namespace: string;
+    alias: string;
+    constructor(alias: string, namespace: string);
+    equals(other: MetadataInclude): boolean;
+    static fromJson(json: any): MetadataInclude;
+}
+export interface IJsonIndex {
+    json: any;
+    index: number;
+}