@microtronics/studio-cli 0.3.5 → 0.4.1

package/dist/studio-cli.d.ts

@@ -1,3 +1,5 @@
+import { LineCounter } from 'yaml';
+import { Range as Range_2 } from 'yaml';
 import { SemVer } from 'semver';
 import { URI } from 'vscode-uri';
 
@@ -223,7 +225,1144 @@ declare interface components {
     pathItems: never;
 }
 
+export declare namespace DDE {
+    import DDEJson = DDE_Core.DDEJson;
+    /**
+     * The json schema to validate the dde structure
+     */
+    const DDE_SCHEMA: {
+        $schema: string;
+        title: string;
+        description: string;
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            dde: {
+                type: string;
+                default: string;
+                readOnly: boolean;
+                description: string;
+            };
+            cloudProject: {
+                type: string;
+            };
+            constants: {
+                type: string;
+                description: string;
+            };
+            state: {
+                $ref: string;
+            };
+            result: {
+                $ref: string;
+            };
+            volatile: {
+                $ref: string;
+            };
+            timeseries: {
+                type: string;
+                description: string;
+                additionalProperties: boolean;
+                maxProperties: number;
+                properties: {
+                    _id: boolean;
+                    id: boolean;
+                    _stamp: boolean;
+                    stamp: boolean;
+                    tag: boolean;
+                    _uid: boolean;
+                    customer_id: boolean;
+                    site_id: boolean;
+                    _rec_flags__: boolean;
+                    applog: boolean;
+                };
+                patternProperties: {
+                    "^(?!.*^field\\d+$)(?!.*^ch\\d+$)[a-zA-Z_][0-9a-zA-Z_]*$": {
+                        $ref: string;
+                    };
+                };
+            };
+            aloha: {
+                type: string;
+                description: string;
+                $ref: string;
+            };
+            setting: {
+                $ref: string;
+            };
+            command: {
+                $ref: string;
+            };
+            storage: {
+                $ref: string;
+            };
+            relations: {
+                $ref: string;
+            };
+        };
+        patternProperties: {
+            "^(?!.*^field\\d+$)(?!.*^ch\\d+$)(?!(dde|cloudProject|constants|state|result|volatile|timeseries|aloha|setting|command|storage|relations))[a-zA-Z_][0-9a-zA-Z_]*$": {
+                type: string;
+                $ref: string;
+            };
+        };
+        allOf: {
+            if: {
+                properties: {
+                    cloudProject: {
+                        const: boolean;
+                    };
+                };
+            };
+            then: {
+                type: string;
+                additionalProperties: boolean;
+                properties: {
+                    dde: {
+                        type: string;
+                        default: string;
+                        readOnly: boolean;
+                        description: string;
+                    };
+                    cloudProject: {
+                        type: string;
+                    };
+                    constants: {
+                        type: string;
+                        description: string;
+                    };
+                    state: {
+                        $ref: string;
+                    };
+                    result: {
+                        $ref: string;
+                    };
+                    volatile: {
+                        $ref: string;
+                    };
+                    timeseries: {
+                        type: string;
+                        description: string;
+                        additionalProperties: boolean;
+                        maxProperties: number;
+                        properties: {
+                            _id: boolean;
+                            id: boolean;
+                            _stamp: boolean;
+                            stamp: boolean;
+                            tag: boolean;
+                            _uid: boolean;
+                            customer_id: boolean;
+                            site_id: boolean;
+                            _rec_flags__: boolean;
+                            applog: boolean;
+                        };
+                        patternProperties: {
+                            "^(?!.*^field\\d+$)(?!.*^ch\\d+$)[a-zA-Z_][0-9a-zA-Z_]*$": {
+                                $ref: string;
+                            };
+                        };
+                    };
+                    aloha: {
+                        type: string;
+                        description: string;
+                        $ref: string;
+                    };
+                    setting: {
+                        $ref: string;
+                    };
+                    command: {
+                        $ref: string;
+                    };
+                    storage: {
+                        $ref: string;
+                    };
+                    relations: {
+                        $ref: string;
+                    };
+                };
+            };
+        }[];
+        $defs: {
+            stateContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            resultContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            volatileContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            alohaContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            settingContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            commandContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            serverStorageContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            serverRelationsContainer: {
+                type: string;
+                title: string;
+                description: string;
+                $ref: string;
+            };
+            configurationFields: {
+                type: string;
+                description: string;
+                additionalProperties: boolean;
+                $ref: string;
+                properties: {};
+                patternProperties: {
+                    "^(?!.*^field\\d+$)(?!.*^ch\\d+$)[a-zA-Z_][0-9a-zA-Z_]*$": {
+                        allOf: {
+                            $ref: string;
+                        }[];
+                    };
+                };
+            };
+            timeseriesFields: {
+                type: string;
+                description: string;
+                additionalProperties: boolean;
+                $ref: string;
+                patternProperties: {
+                    "^(?!.*^field\\d+$)(?!.*^ch\\d+$)[a-zA-Z_][0-9a-zA-Z_]*$": {
+                        allOf: ({
+                            $ref: string;
+                            type?: undefined;
+                            properties?: undefined;
+                            dependencies?: undefined;
+                        } | {
+                            type: string;
+                            properties: {
+                                channelMode: {
+                                    type: string[];
+                                    description: string;
+                                    anyOf: ({
+                                        const: string;
+                                        description: string;
+                                        $ref?: undefined;
+                                    } | {
+                                        $ref: string;
+                                        const?: undefined;
+                                        description?: undefined;
+                                    })[];
+                                };
+                                chartAlarmLow: {
+                                    title: string;
+                                    $ref: string;
+                                };
+                                chartAlarmHigh: {
+                                    title: string;
+                                    $ref: string;
+                                };
+                                chartWarningLow: {
+                                    title: string;
+                                    $ref: string;
+                                };
+                                chartWarningHigh: {
+                                    title: string;
+                                    $ref: string;
+                                };
+                                chartHysteresis: {
+                                    title: string;
+                                    type: string[];
+                                    description: string;
+                                    $ref: string;
+                                };
+                                chartTriggerThreshold: {
+                                    title: string;
+                                    type: string[];
+                                    description: string;
+                                    $ref: string;
+                                };
+                                chartTriggerRelation: {
+                                    title: string;
+                                    type: string[];
+                                    description: string;
+                                    anyOf: ({
+                                        title: string;
+                                        description: string;
+                                        const: string;
+                                        $ref?: undefined;
+                                    } | {
+                                        $ref: string;
+                                        title?: undefined;
+                                        description?: undefined;
+                                        const?: undefined;
+                                    })[];
+                                };
+                                chartSetPoint: {
+                                    title: string;
+                                    type: string[];
+                                    description: string;
+                                    $ref: string;
+                                };
+                            };
+                            dependencies: {
+                                chartTriggerRelation: string[];
+                            };
+                            $ref?: undefined;
+                        })[];
+                    };
+                };
+            };
+            reservedNamesFieldNames: {
+                type: string;
+                properties: {
+                    _id: boolean;
+                    id: boolean;
+                    _stamp: boolean;
+                    stamp: boolean;
+                    tag: boolean;
+                    _uid: boolean;
+                    customer_id: boolean;
+                    site_id: boolean;
+                    _rec_flags__: boolean;
+                    applog: boolean;
+                };
+            };
+            defaultFieldProperties: {
+                type: string;
+                additionalProperties: boolean;
+                properties: {
+                    type: {
+                        $ref: string;
+                    };
+                    title: {
+                        type: string;
+                        description: string;
+                    };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
+                    array: {
+                        type: string;
+                        description: string;
+                        minimum: number;
+                        inclusiveMaximum: number;
+                    };
+                    unit: {
+                        type: string;
+                        description: string;
+                    };
+                    hex: {
+                        type: string;
+                        description: string;
+                    };
+                    decimalPlaces: {
+                        $ref: string;
+                    };
+                    writePermission: {
+                        description: string;
+                        anyOf: ({
+                            $ref: string;
+                            const?: undefined;
+                            title?: undefined;
+                            description?: undefined;
+                        } | {
+                            const: string;
+                            title: string;
+                            description: string;
+                            $ref?: undefined;
+                        })[];
+                    };
+                    readPermission: {
+                        description: string;
+                        $ref: string;
+                    };
+                    bytes: boolean;
+                    fields: boolean;
+                    length: boolean;
+                    defaultValue: boolean;
+                    channelMode: boolean;
+                    scale: boolean;
+                    offset: boolean;
+                    chartMinimum: boolean;
+                    chartMaximum: boolean;
+                    chartAlarmLow: boolean;
+                    chartAlarmHigh: boolean;
+                    chartWarningLow: boolean;
+                    chartWarningHigh: boolean;
+                    chartHysteresis: boolean;
+                    chartTriggerThreshold: boolean;
+                    chartTriggerRelation: boolean;
+                    chartSetPoint: boolean;
+                    utilsTransferInterval: boolean;
+                    shadowFields: {
+                        type: string;
+                        deprecated: boolean;
+                        title: string;
+                        description: string;
+                        $ref: string;
+                    };
+                    bitmask: {
+                        type: string;
+                        title: string;
+                        description: string;
+                        anyOf: {
+                            default: string;
+                            pattern: string;
+                            description: string;
+                        }[];
+                    };
+                };
+                required: string[];
+                allOf: ({
+                    if: {
+                        description: string;
+                        properties: {
+                            type: {
+                                enum: string[];
+                            };
+                            title?: undefined;
+                            unit?: undefined;
+                        };
+                    };
+                    then: {
+                        properties: {
+                            bytes: {
+                                type: string;
+                                description: string;
+                            };
+                            defaultValue: {
+                                type: string;
+                                description: string;
+                                pattern: string;
+                            };
+                            length?: undefined;
+                            decimalPlaces?: undefined;
+                            chartMinimum?: undefined;
+                            chartMaximum?: undefined;
+                            scale?: undefined;
+                            offset?: undefined;
+                            utilsTransferInterval?: undefined;
+                            title?: undefined;
+                            unit?: undefined;
+                        };
+                        required: string[];
+                    };
+                    else: {
+                        properties: {
+                            bytes: boolean;
+                            decimalPlaces?: undefined;
+                            chartMinimum?: undefined;
+                            chartMaximum?: undefined;
+                            scale?: undefined;
+                            offset?: undefined;
+                        };
+                    };
+                } | {
+                    if: {
+                        description: string;
+                        properties: {
+                            type: {
+                                enum: string[];
+                            };
+                            title?: undefined;
+                            unit?: undefined;
+                        };
+                    };
+                    then: {
+                        properties: {
+                            length: {
+                                type: string;
+                                description: string;
+                                minimum: number;
+                            };
+                            defaultValue: {
+                                type: string;
+                                description?: undefined;
+                                pattern?: undefined;
+                            };
+                            bytes?: undefined;
+                            decimalPlaces?: undefined;
+                            chartMinimum?: undefined;
+                            chartMaximum?: undefined;
+                            scale?: undefined;
+                            offset?: undefined;
+                            utilsTransferInterval?: undefined;
+                            title?: undefined;
+                            unit?: undefined;
+                        };
+                        required: string[];
+                    };
+                    else?: undefined;
+                } | {
+                    if: {
+                        properties: {
+                            type: {
+                                enum: string[];
+                            };
+                            title?: undefined;
+                            unit?: undefined;
+                        };
+                        description?: undefined;
+                    };
+                    then: {
+                        properties: {
+                            decimalPlaces: {
+                                $ref: string;
+                            };
+                            defaultValue: {
+                                type: string[];
+                                description: string;
+                                pattern: string;
+                            };
+                            chartMinimum: {
+                                type: string[];
+                                description: string;
+                                $ref: string;
+                            };
+                            chartMaximum: {
+                                type: string[];
+                                description: string;
+                                $ref: string;
+                            };
+                            scale: {
+                                type: string[];
+                                title: string;
+                                description: string;
+                                $ref: string;
+                            };
+                            offset: {
+                                type: string[];
+                                title: string;
+                                description: string;
+                                $ref: string;
+                            };
+                            utilsTransferInterval: {
+                                title: string;
+                                type: string[];
+                                description: string;
+                            };
+                            bytes?: undefined;
+                            length?: undefined;
+                            title?: undefined;
+                            unit?: undefined;
+                        };
+                        required?: undefined;
+                    };
+                    else: {
+                        properties: {
+                            decimalPlaces: boolean;
+                            chartMinimum: boolean;
+                            chartMaximum: boolean;
+                            scale: boolean;
+                            offset: boolean;
+                            bytes?: undefined;
+                        };
+                    };
+                } | {
+                    if: {
+                        description: string;
+                        properties: {
+                            title: {
+                                pattern: string;
+                            };
+                            type?: undefined;
+                            unit?: undefined;
+                        };
+                    };
+                    then: {
+                        properties: {
+                            title: {
+                                $ref: string;
+                            };
+                            bytes?: undefined;
+                            defaultValue?: undefined;
+                            length?: undefined;
+                            decimalPlaces?: undefined;
+                            chartMinimum?: undefined;
+                            chartMaximum?: undefined;
+                            scale?: undefined;
+                            offset?: undefined;
+                            utilsTransferInterval?: undefined;
+                            unit?: undefined;
+                        };
+                        required?: undefined;
+                    };
+                    else?: undefined;
+                } | {
+                    if: {
+                        description: string;
+                        properties: {
+                            unit: {
+                                pattern: string;
+                            };
+                            type?: undefined;
+                            title?: undefined;
+                        };
+                    };
+                    then: {
+                        properties: {
+                            unit: {
+                                $ref: string;
+                            };
+                            bytes?: undefined;
+                            defaultValue?: undefined;
+                            length?: undefined;
+                            decimalPlaces?: undefined;
+                            chartMinimum?: undefined;
+                            chartMaximum?: undefined;
+                            scale?: undefined;
+                            offset?: undefined;
+                            utilsTransferInterval?: undefined;
+                            title?: undefined;
+                        };
+                        required?: undefined;
+                    };
+                    else?: undefined;
+                })[];
+            };
+            dataTypes: {
+                type: string;
+                description: string;
+                anyOf: ({
+                    const: string;
+                    title: string;
+                    description: string;
+                } | {
+                    const: string;
+                    title: string;
+                    description?: undefined;
+                })[];
+            };
+            userLevel: {
+                type: string;
+                description: string;
+                anyOf: ({
+                    const: string;
+                    title: string;
+                    description: string;
+                    pattern?: undefined;
+                } | {
+                    pattern: string;
+                    const?: undefined;
+                    title?: undefined;
+                    description?: undefined;
+                })[];
+            };
+            configArrayDefinition: {
+                if: {
+                    description: string;
+                    properties: {
+                        type: {
+                            const: string;
+                        };
+                    };
+                };
+                then: {
+                    properties: {
+                        fields: {
+                            $ref: string;
+                        };
+                        length: {
+                            type: string;
+                            description: string;
+                            minimum: number;
+                            inclusiveMaximum: number;
+                        };
+                        array: boolean;
+                        title: boolean;
+                    };
+                    required: string[];
+                };
+                else: {
+                    properties: {
+                        fields: boolean;
+                    };
+                };
+            };
+            timeseriesArrayDefinition: {
+                if: {
+                    description: string;
+                    properties: {
+                        type: {
+                            const: string;
+                        };
+                    };
+                };
+                then: {
+                    properties: {
+                        fields: {
+                            $ref: string;
+                        };
+                        length: {
+                            type: string;
+                            description: string;
+                            minimum: number;
+                            inclusiveMaximum: number;
+                        };
+                        array: boolean;
+                        title: boolean;
+                    };
+                    required: string[];
+                };
+                else: {
+                    properties: {
+                        fields: boolean;
+                    };
+                };
+            };
+            decimalPlaces: {
+                type: string[];
+                description: string;
+                minimum: number;
+                $ref: string;
+            };
+            relationLinkPattern: {
+                anyOf: {
+                    pattern: string;
+                }[];
+            };
+            setPointRelationPattern: {
+                anyOf: ({
+                    pattern: string;
+                    const?: undefined;
+                    description?: undefined;
+                    title?: undefined;
+                } | {
+                    const: string;
+                    description: string;
+                    title: string;
+                    pattern?: undefined;
+                })[];
+            };
+            chartAlarmWarn: {
+                type: string[];
+                description: string;
+                $ref: string;
+            };
+        };
+    };
+    export function readYamlFile(filePath: URI, fs: LocalFS): Promise<string>;
+    /**
+     * Validate all dde files if they are valid based on the json schema
+     * @param cwd
+     * @param fs
+     * @param fileName
+     */
+    export function validate(cwd: URI, fs: LocalFS, fileName?: string): Promise<{
+        manifest: Manifest.Manifest;
+        libraryFiles: DDE_Core.LibraryFile[];
+        main: {
+            path: URI;
+            yaml: string;
+        };
+    }>;
+    /**
+     * Run dde compiler in the given studio directory
+     * @param cwd
+     * @param fs
+     * @param fileName
+     */
+    export function compileDDE(cwd: URI, fs: LocalFS, fileName?: string): Promise<{
+        ddeJSON: DDEJson | null;
+        diagnostics: Diagnostics.File[];
+    }>;
+    /**
+     * Validate a given dde file against the dynamic dde schema
+     * @param ddeFilePath
+     * @param yaml
+     */
+    export function validateJsonSchema(ddeFilePath: URI, yaml: string): Promise<void>;
+    /**
+     * Creates and returns a new precompiler instance
+     * @param manifest
+     * @param libraries
+     * @param ddeHistory
+     * @constructor
+     */
+    const PreCompiler: (manifest: Manifest.Manifest, libraries: DDE_Core.LibraryFile[], ddeHistory: any) => YamlPreCompiler.PreCompiler;
+    /**
+     * File Generators
+     */
+    /**
+     * Generate the needed xml for the myDatanet application
+     * @param ddeJSON
+     */
+    export function generateMyDatanetXML(ddeJSON: DDEJson): string;
+    /**
+     * Generate the xml dde notation and write it to the correct dist directory
+     * @param cwd
+     * @param fs
+     * @param ddeJSON
+     */
+    export function exportMyDatanetXML(cwd: URI, fs: LocalFS, ddeJSON: DDEJson): Promise<void>;
+}
+
+export declare namespace DDE_Core {
+    export interface DDEJson {
+        containers: {
+            [key: string]: DDEJsonContainer;
+        };
+        setPointList: DDESetpointList;
+    }
+    export interface DDESetpointList {
+        [key: string]: number;
+    }
+    export interface DDEJsonContainer {
+        name: ContainerName;
+        containerType: ContainerType;
+        volatile: boolean;
+        title: string;
+        previousTitle?: string;
+        libraries: string[];
+        knownNames: string[];
+        transferDirection: TransferDirection;
+        size: number;
+        fieldCount: number;
+        arrays: {
+            [key: string]: ArrayInfo;
+        };
+        shadows: {
+            [key: string]: ShadowInfo;
+        };
+        fields: DDEJsonField[];
+        fieldIndex: number;
+    }
+    export interface ArrayInfo {
+        name: string;
+        length: number;
+        library: null | string;
+        fields?: ArrayRefField[];
+    }
+    export interface ShadowInfo {
+        name: string;
+        byteSize: number;
+        byteOffset: number;
+    }
+    export interface YamlDDEField {
+        type: string;
+        title?: null | string;
+        description?: string;
+        unit?: string;
+        hex?: boolean;
+        decimalPlaces?: number;
+        writePermission?: number;
+        readPermission?: number;
+        channelMode?: number | string;
+        defaultValue?: number | string;
+        scale?: number | string;
+        offset?: number | string;
+        chartMinimum?: number | string;
+        chartMaximum?: number | string;
+        chartAlarmLow?: number | string;
+        chartAlarmHigh?: number | string;
+        chartWarningLow?: number | string;
+        chartWarningHigh?: number | string;
+        chartHysteresis?: number | string;
+        chartTriggerThreshold?: number | string;
+        chartTriggerRelation?: number | string;
+        chartSetPoint?: number | string;
+        utilsTransferInterval?: boolean;
+        bitmask?: string;
+        bytes?: number;
+        array?: number;
+        length?: number;
+    }
+    export interface DDEJsonField extends YamlDDEField {
+        name: string;
+        index: number;
+        id: string;
+        library: null | string;
+        byteOffset: number;
+        byteSize: number;
+        arrayRef: null | ArrayRef;
+        shadowRef: null | string;
+        defaultDloDefine?: string;
+    }
+    export interface ArrayRef {
+        name: string;
+        index: number;
+    }
+    export interface ArrayRefField {
+        name: string;
+        type: string;
+        byteSize: number;
+    }
+    export enum DDEContainerName {
+        /** @description low frequent - from device to server */
+        state = "state",
+        /** @description high frequent - from device to server */
+        result = "result",
+        /** @description aloha - from device to server */
+        aloha = "aloha",
+        /** @description volatile - from device to server */
+        volatile = "volatile",
+        /** @description low frequent - from server to device */
+        setting = "setting",
+        /** @description high frequent - from server to device */
+        command = "command",
+        /** @description server only */
+        storage = "storage",
+        /** @description server only */
+        relations = "relations"
+    }
+    export enum ContainerName {
+        configA = "configA",
+        configB = "configB",
+        configC = "configC",
+        config0 = "config0",
+        config1 = "config1",
+        config2 = "config2",
+        config3 = "config3",
+        config4 = "config4",
+        config5 = "config5",
+        config6 = "config6",
+        config7 = "config7",
+        config8 = "config8",
+        config9 = "config9",
+        histdata0 = "histdata0",
+        histdata1 = "histdata1",
+        histdata2 = "histdata2",
+        histdata3 = "histdata3",
+        histdata4 = "histdata4",
+        histdata5 = "histdata5",
+        histdata6 = "histdata6",
+        histdata7 = "histdata7",
+        histdata8 = "histdata8",
+        histdata9 = "histdata9",
+        aloha = "aloha",
+        alerts = "alerts",
+        applog = "applog"
+    }
+    export enum ContainerType {
+        /**
+         * @description config0 - 9
+         */
+        cx = "cx",
+        /**
+         * @description histdata0 - 9
+         */
+        hx = "hx",
+        /**
+         * @description configA - B
+         */
+        cb = "cb",
+        aloha = "aloha",
+        applog = "applog"
+    }
+    export enum TransferDirection {
+        up = "up",
+        down = "down",
+        upPlus = "up+",
+        downPlus = "down+",
+        none = "none",
+        backendOnly = "backend-only",
+        deviceOnly = "device-only",
+        both = "both",
+        bothPlus = "both+",
+        /** @deprecated replaced with backendOnly*/
+        noneBackend = "none-be"
+    }
+    export function CONTAINER_DEF_DLO_CID_BASE(containerType: ContainerType, xmit: TransferDirection): "DDE_CID_CONFIG" | "DDE_CID_HISTDATA" | "DDE_CID_ALOHA" | null;
+    export interface ContainerDefinition {
+        ctype: ContainerType | undefined;
+        cnum: 'a' | 'b' | 'c' | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
+        alias: string;
+        flds: 'field' | 'ch' | null;
+        xmits: TransferDirection[];
+    }
+    export type ContainerDefinitions = {
+        [key in ContainerName]: ContainerDefinition;
+    };
+    const CONTAINER_DEFS: ContainerDefinitions;
+    const HISTDATA_CONTAINER: ContainerName[];
+    const CONFIG_CONTAINER: ContainerName[];
+    const SERVER_CONTAINER: ContainerName[];
+    const regexRelation: RegExp;
+    /**
+     * Defines what fields allow relations and the allowed target field type.
+     */
+    const allowedRelationTypes: {
+        title: string[];
+        unit: string[];
+        chartMinimum: string[];
+        chartMaximum: string[];
+        scale: string[];
+        offset: string[];
+        decimalPlaces: string[];
+        channelMode: string[];
+        chartAlarmLow: string[];
+        chartAlarmHigh: string[];
+        chartWarningLow: string[];
+        chartWarningHigh: string[];
+        chartHysteresis: string[];
+        chartTriggerThreshold: string[];
+        chartTriggerRelation: string[];
+        chartSetPoint: string[];
+    };
+    export type AllowedRelationTypse = keyof typeof allowedRelationTypes;
+    /**
+     * Parse the given value and resolve any container relation
+     * @param attribute
+     * @param field
+     * @param ddeMap
+     */
+    export function parseXMLValueWithRelation(attribute: AllowedRelationTypse, field: DDEJsonField, ddeMap: DDEJson): any;
+    export function parseXMLBitmask(field: DDEJsonField): string | undefined;
+    export function parseXMLDefaultValue(field: DDEJsonField): string | number | undefined;
+    const TDEF_NUMBER: {
+        xmlOut(xml: XMLField, jsonField: DDEJsonField, ddeMap: DDEJson): void;
+    };
+    const TYPE_DEFS: any;
+    const fieldTypeDefinitions: {
+        uint8: any;
+        uint16: any;
+        uint32: any;
+        int8: any;
+        int16: any;
+        int32: any;
+        int64: any;
+        float16: any;
+        float32: any;
+        float64: any;
+        stamp32: any;
+        stamp40: any;
+        binary: any;
+        astring: any;
+        nstring: any;
+        wstring: any;
+        ustring: any;
+        cstring: any;
+    };
+    export function checkForReservedFieldName(fieldName: string): boolean;
+    export interface LibraryFile {
+        /**
+         * Name of the library this file comes from
+         */
+        libraryName: string;
+        /**
+         * The original filepath of the file
+         */
+        path: URI;
+        /**
+         * The content of the included file
+         */
+        yaml: string;
+    }
+        {};
+}
+
+export declare namespace DefaultFiles {
+    const fileNames: {
+        projectSettings: string;
+        mainAmx: string;
+        mainAmxReport: string;
+        ddeXml: string;
+        ddeOpenApi: string;
+        ddeJson: string;
+        mainDDE: string;
+        autoInc: string;
+        defaultInc: string;
+        autoUplinkInc: string;
+        autoDdeInc: string;
+        mainDdeInc: string;
+        legacyAutoInc: string;
+        legacyAutoDdeInc: string;
+        legacyAutoUplinkInc: string;
+        reportTemplate: string;
+    };
+    const filePaths: {
+        studio: {
+            initFile: string;
+            auto: {
+                path: string;
+                dlo: {
+                    path: string;
+                    autoInc: string;
+                    defaultInc: string;
+                    autoUplinkInc: string;
+                    autoDdeInc: string;
+                    mainDdeInc: string;
+                    legacyAutoInc: string;
+                    legacyAutoDdeInc: string;
+                    legacyAutoUplinkInc: string;
+                };
+            };
+            libdeps: string;
+        };
+        dist: {
+            path: string;
+            mainAmxPath: string;
+            mainAmxReportPath: string;
+            ddeXmlPath: string;
+            ddeApiPath: string;
+            ddeApi: string;
+            ddeJson: string;
+            povPath: string;
+            povDetailsPath: string;
+            dfilesPath: string;
+            dfilesProperties: string;
+            bloPath: string;
+            reportTemplate: string;
+        };
+        dlo: {
+            path: string;
+            mainDLO: string;
+            mainINI: string;
+        };
+        dde: {
+            path: string;
+            mainDDE: string;
+        };
+        dfiles: {
+            path: string;
+            mainDFILES: string;
+        };
+    };
+}
+
 export declare namespace Dependencies {
+    /**
+     * Just combine all dependencies in one object
+     * Optional devDependencies can be excluded
+     * @param manifest
+     * @param production - set to true if devDependencies should be excluded
+     */
+    export function getAll(manifest: Manifest.Manifest, production?: boolean): Promise<Manifest.Dependencies>;
+    /**
+     * get the library name from the dependency id
+     * eg. Microtronics/dlo-core -> dlo-core
+     * @param dependencyId
+     */
+    export function dependencyIdToName(dependencyId: string): string;
+    /**
+     * convert a dependency id to the libdeps path
+     * eg. Microtronics/dlo-core would result into <cwd>/.studio/libdeps/dlo-core
+     * @param cwd
+     * @param dependencyId
+     */
+    export function dependencyToPath(cwd: URI, dependencyId: string): URI;
     /**
      * Removes the caret-range constraint from the version
      * @public
@@ -298,6 +1437,25 @@ export declare namespace Dependencies {
     export function uninstallDependency(cwd: URI, fs: LocalFS, publisherId: string, libraryName: string): Promise<void>;
 }
 
+export declare namespace Diagnostics {
+    const CODE: {
+        ddeFieldLength: string;
+    };
+    export type Level = 'error' | 'warning' | 'hint' | 'info';
+    /**
+     * Generic diagnostic type for unified responses
+     */
+    export interface File {
+        file: URI;
+        level: Level;
+        code?: string;
+        line: number;
+        startCharacter?: number;
+        endCharacter?: number;
+        message: string;
+    }
+}
+
 /**
  * Permissions of a file.
  */
@@ -376,6 +1534,19 @@ declare enum FileType {
     SymbolicLink = 64
 }
 
+export declare namespace Helper {
+    /**
+     * Convert yaml range to an valid vscode line information
+     * @param lineCounter
+     * @param fieldRange
+     */
+    export function yamlRangeToLineInformation(lineCounter: LineCounter, fieldRange: Range_2): {
+        line: number;
+        startCharacter: number;
+        endCharacter: number;
+    };
+}
+
 declare interface LocalFS {
     /**
      * Filesystem rm function. It has to remove files or paths recursive
@@ -455,6 +1626,10 @@ export declare namespace Manifest {
      * @param manifest
      */
     export function write(cwd: URI, fs: LocalFS, manifest: Manifest): Promise<Manifest>;
+    /**
+     * Check if the current project is a library project
+     */
+    export function isLibraryProject(manifest: Manifest.Manifest): boolean;
 }
 
 export declare namespace Registry {
@@ -476,4 +1651,96 @@ export declare namespace Registry {
     export function fetchLibraryContent(token: string | null, contentURL: string, json?: boolean): Promise<any>;
 }
 
+declare interface XMLField {
+    alias: string;
+    byteofs?: string;
+    index?: string;
+    title: string;
+    name: string;
+    upload?: '0';
+    download?: '0';
+    decpl?: number | string;
+    param0?: string;
+    units?: string;
+    editmask?: string;
+    view?: number;
+    edit?: number;
+    chmode?: number | string;
+    default?: string | number;
+    vscale?: number | string;
+    vofs?: number | string;
+    min?: number | string;
+    max?: number | string;
+    ialarm_low?: number | string;
+    ialarm_high?: number | string;
+    iwarn_low?: number | string;
+    iwarn_high?: number | string;
+    hysterese?: number | string;
+    itrigger?: number | string;
+    itriggerus?: number | string;
+    setpoint?: string;
+    bitmask?: string;
+}
+
+declare namespace YamlPreCompiler {
+    class PreCompiler {
+        private manifest;
+        private libraryFiles;
+        private ddeHistory;
+        private readonly fieldNamesPerContainer;
+        private readonly usedContainerNames;
+        private fileDiagnostics;
+        private readonly libraryDDE;
+        constructor(manifest: Manifest.Manifest, libraryFiles: DDE_Core.LibraryFile[], ddeHistory: any);
+        /**
+         * Parse the given library files and return the diagnostics
+         */
+        parseLibraries(): Diagnostics.File[];
+        private get previousVersion();
+        private getContainerOfPreviousVersion;
+        parseMainDDE(filePath: URI, yaml: string): {
+            ddeJSON: DDEJson | null;
+            diagnostics: Diagnostics.File[];
+        };
+        /**
+         * Parse a given yaml file
+         * @param filePath
+         * @param yaml
+         * @param libraryName
+         */
+        parseYamlFile(filePath: URI, yaml: string, libraryName?: string): {
+            parsedDDE: DDEJson;
+            diagnostics: Diagnostics.File[];
+        };
+        private yamlDocToDdeJson;
+        private getRealContainerInformation;
+        private findNextFreeContainer;
+        private findPreviousUsedContainer;
+        private createDDEJsonFields;
+        private buildDDEJsonField;
+        private resolvePossibleAlias;
+        private validateContainerDefinition;
+        private parseUserLevel;
+        private parseChannelMode;
+        private parseTriggerUndershoot;
+        private validateAllowedContainer;
+        private validateContainerFields;
+        private checkForContainerRelation;
+        private validateFieldName;
+        private checkFieldNameLength;
+        private validateContainerRelation;
+        private findRelatedShadowField;
+        private mergeAndFormat;
+        private combineDDE;
+        private initialContainerByteOffset;
+        private updateShadowFieldInformation;
+        private sortContainerFields;
+        private sortFields;
+        private sortPreviousContainerFields;
+        private generatePlaceholderFieldIfNeeded;
+        private generateSetPointList;
+        private getNextSetpointValue;
+    }
+}
+
 export { }