node-opcua-address-space 2.89.0 → 2.90.1

package/src/ua_variable_impl.ts

@@ -86,6 +86,8 @@ import { apply_condition_refresh, ConditionRefreshCache } from "./apply_conditio
 import {
     extractPartialData,
     incrementElement,
+    propagateTouchValueDownward,
+    propagateTouchValueDownwardArray,
     propagateTouchValueUpward,
     setExtensionObjectPartialValue,
     _bindExtensionObject,
@@ -245,6 +247,17 @@ function default_func(this: UAVariable, dataValue1: DataValue, callback1: Callba
 interface UAVariableOptions extends InternalBaseNodeOptions {
     value?: any;
     dataType: NodeId | string;
+    /**
+     * This attribute indicates whether the Value attribute of the Variableis an array and how many dimensions the array has.
+     * It may have the following values:
+     *   * n > 1: the Value is an array with the specified number of dimensions.
+     *   * OneDimension (1): The value is an array with one dimension.
+     *   * OneOrMoreDimensions (0): The value is an array with one or more dimensions.
+     *   * Scalar (−1): The value is not an array.
+     *   * Any (−2): The value can be a scalar or an array with any number of dimensions.
+     *   * ScalarOrOneDimension (−3): The value can be a scalar or a one dimensional array.
+     *   * All DataTypes are considered to be scalar, even if they have array-like semantics like ByteString and String.
+     */
     valueRank?: number;
     arrayDimensions?: null | number[];
     accessLevel?: any;
@@ -286,6 +299,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     private _basicDataType?: DataType;
 
     public $extensionObject?: any;
+    public $set_ExtensionObject?: (newValue: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => void;
 
     public $historicalDataConfiguration?: UAHistoricalDataConfiguration;
     public varHistorian?: IVariableHistorian;
@@ -312,6 +326,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     get typeDefinitionObj(): UAVariableType {
         // istanbul ignore next
         if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== NodeClass.VariableType) {
+            console.log(super.typeDefinitionObj.toString());
             throw new Error(
                 "Invalid type definition node class , expecting a VariableType got " + NodeClass[super.typeDefinitionObj.nodeClass]
             );
@@ -524,6 +539,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
     public isExtensionObject(): boolean {
         // DataType must be one of Structure
+        if (this.dataType.isEmpty()) return false;
         const dataTypeNode = this.addressSpace.findDataType(this.dataType) as UADataType;
         if (!dataTypeNode) {
             throw new Error(" Cannot find  DataType  " + this.dataType.toString() + " in standard address Space");
@@ -572,9 +588,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             dataValue.serverPicoseconds = 0;
             return callback(null, dataValue);
         }
-
         try {
             this.refreshFunc.call(this, (err: Error | null, dataValue?: DataValueLike) => {
+                // istanbul ignore next
                 if (err || !dataValue) {
                     errorLog(
                         "-------------- refresh call failed",
@@ -814,19 +830,20 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             if (dataValue.value.dataType === DataType.ExtensionObject) {
                 const valueIsCorrect = this.checkExtensionObjectIsCorrect(dataValue.value.value);
                 if (!valueIsCorrect) {
-                    errorLog("Invalid value !");
+                    errorLog("setValueFromSource Invalid value !");
                     errorLog(this.toString());
                     errorLog(dataValue.toString());
                     this.checkExtensionObjectIsCorrect(dataValue.value.value);
                 }
-                this.$dataValue = dataValue;
                 // ----------------------------------
-                if (this.$extensionObject) {
+                if (this.$extensionObject || this.$$extensionObjectArray) {
                     // we have an extension object already bound to this node
                     // the client is asking us to replace the object entierly by a new one
                     // const ext = dataValue.value.value;
                     this._internal_set_dataValue(dataValue);
                     return;
+                } else {
+                    this.$dataValue = dataValue;
                 }
             } else {
                 this._internal_set_dataValue(dataValue);
@@ -1283,6 +1300,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             const n = callbacks.length;
             for (const callback1 of callbacks) {
                 callback1.call(this, err, dataValue);
+
             }
         };
 
@@ -1487,12 +1505,21 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         optionalExtensionObject?: ExtensionObject | ExtensionObject[],
         options?: BindExtensionObjectOptions
     ): ExtensionObject | ExtensionObject[] | null {
+
+        // coerce to ExtensionObject[] when this.valueRank === 1
+        if (optionalExtensionObject && this.valueRank === 1 && !Array.isArray(optionalExtensionObject) && optionalExtensionObject instanceof ExtensionObject) {
+            warningLog("bindExtensionObject: coerce to ExtensionObject[] when this.valueRank === 1");
+            optionalExtensionObject = [optionalExtensionObject];
+        }
+
         if (optionalExtensionObject) {
             if (optionalExtensionObject instanceof Array) {
-                assert(this.valueRank >= 1, "expecting an Array of Matrix variable here");
+                assert(this.valueRank >= 1, "bindExtensionObject: expecting an Array of Matrix variable here");
                 return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
             } else {
-                assert(this.valueRank === -1, "expecting an Scalar variable here");
+                if (this.valueRank !== -1 && this.valueRank !== 0) {
+                    throw new Error("bindExtensionObject: expecting an Scalar variable here but got value rank " + this.valueRank);
+                }
                 return _bindExtensionObject(this, optionalExtensionObject, options) as ExtensionObject;
             }
         }
@@ -1712,7 +1739,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 throw new Error("Invalid Extension Object on nodeId =" + this.nodeId.toString());
             }
         }
-   
+
         this.verifyVariantCompatibility(dataValue.value);
 
         this._inner_replace_dataValue(dataValue, indexRange);
@@ -1722,23 +1749,59 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
      * @private
      */
     public _inner_replace_dataValue(dataValue: DataValue, indexRange?: NumericRange | null) {
-        const old_dataValue = this.$dataValue;
 
-        this.$dataValue = dataValue;
-        this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
+        assert(this.$dataValue.value instanceof Variant);
+        const old_dataValue = this.$dataValue.clone();
 
+        if (this.$$extensionObjectArray && dataValue.value.arrayType !== VariantArrayType.Scalar) {
+            // we have a bounded array or matrix
+            assert(Array.isArray(dataValue.value.value));
+            if (this.$$extensionObjectArray !== this.$dataValue.value.value) {
+                throw new Error("internal error");
+            }
+            this.$$extensionObjectArray = dataValue.value.value;
+            this.$dataValue.value.value = dataValue.value.value;
+
+            this.$dataValue.statusCode = dataValue.statusCode || StatusCodes.Good;
+            this.$dataValue.serverTimestamp = dataValue.serverTimestamp;
+            this.$dataValue.serverPicoseconds = dataValue.serverPicoseconds;
+            this.$dataValue.sourceTimestamp = dataValue.sourceTimestamp;
+            this.$dataValue.sourcePicoseconds = dataValue.sourcePicoseconds;
+
+        } else if (this._basicDataType === DataType.ExtensionObject && this.valueRank === -1 && this.$set_ExtensionObject && dataValue.value.arrayType === VariantArrayType.Scalar) {
+            // the entire extension object is changed. 
+            this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
+            const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
+            this.$set_ExtensionObject(dataValue.value.value, preciseClock, new Set())
+        } else {
+            this.$dataValue = dataValue;
+            this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
+        }
         // repair missing timestamps
+        const now = new Date();
         if (!dataValue.serverTimestamp) {
-            this.$dataValue.serverTimestamp = old_dataValue.serverTimestamp;
-            this.$dataValue.serverPicoseconds = old_dataValue.serverPicoseconds;
+            this.$dataValue.serverTimestamp = old_dataValue.serverTimestamp || now;
+            this.$dataValue.serverPicoseconds = old_dataValue.serverPicoseconds || 0;
         }
         if (!dataValue.sourceTimestamp) {
-            this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp;
-            this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds;
+            this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp || now;
+            this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds || 0;
         }
 
         if (!sameDataValue(old_dataValue, dataValue)) {
-            this.emit("value_changed", this.$dataValue, indexRange);
+            if (this.getBasicDataType() === DataType.ExtensionObject) {
+                const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
+                const cache: Set<UAVariable> = new Set();
+                if (this.$$extensionObjectArray) {
+                    this.touchValue(preciseClock);
+                    propagateTouchValueDownwardArray(this, preciseClock, cache);
+                } else {
+                    this.touchValue(preciseClock);
+                    propagateTouchValueDownward(this, preciseClock, cache);
+                }
+            } else {
+                this.emit("value_changed", this.$dataValue, indexRange);
+            }
         }
     }
 
@@ -2067,7 +2130,7 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOpt
     this._get_func = options.get;
 
     const timestamped_get_func_from__Variable_bind_with_simple_get = () => {
-        const value = this._get_func();
+        const value: Variant | StatusCode = this._get_func();
 
         /* istanbul ignore next */
         if (!is_Variant_or_StatusCode(value)) {
@@ -2081,10 +2144,10 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOpt
             );
         }
         if (is_StatusCode(value)) {
-            return new DataValue({ statusCode: value });
+            return new DataValue({ statusCode: value as StatusCode });
         } else {
-            if (!this.$dataValue || !this.$dataValue.statusCode.isGoodish() || !sameVariant(this.$dataValue.value, value)) {
-                this.setValueFromSource(value, StatusCodes.Good);
+            if (!this.$dataValue || !this.$dataValue.statusCode.isGoodish() || !sameVariant(this.$dataValue.value, value as Variant)) {
+                this._inner_replace_dataValue(new DataValue({ value }));
             }
             return this.$dataValue;
         }

package/src/ua_variable_impl_ext_obj.ts

@@ -104,12 +104,12 @@ export function _touchValue(property: UAVariableImpl, now: PreciseClock): void {
     property.$dataValue.serverTimestamp = now.timestamp;
     property.$dataValue.serverPicoseconds = now.picoseconds;
     property.$dataValue.statusCode = StatusCodes.Good;
-    if (property.minimumSamplingInterval === 0) {
-        if (property.listenerCount("value_changed") > 0) {
-            const clonedDataValue = property.readValue();
-            property.emit("value_changed", clonedDataValue);
-        }
+    // if (property.minimumSamplingInterval === 0) {
+    if (property.listenerCount("value_changed") > 0) {
+        const clonedDataValue = property.readValue();
+        property.emit("value_changed", clonedDataValue);
     }
+    // }
 }
 
 export function propagateTouchValueUpward(self: UAVariableImpl, now: PreciseClock, cache?: Set<UAVariable>): void {
@@ -126,7 +126,7 @@ export function propagateTouchValueUpward(self: UAVariableImpl, now: PreciseCloc
     }
 }
 
-function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseClock, cache?: Set<UAVariable>): void {
+export function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseClock, cache?: Set<UAVariable>): void {
     if (!self.isExtensionObject()) return;
     // also propagate changes to embeded variables
     const dataTypeNode = self.getDataTypeNode();
@@ -265,7 +265,7 @@ function installExt(uaVariable: UAVariableImpl, ext: ExtensionObject) {
                         return uaVariable.getComponentByName(field.name!) as UAVariable | null;
                     }));
                 } else {
-                    warningLog("extension object is null");
+                    doDebug && warningLog("extension object is null");
                 }
             }
         }
@@ -336,7 +336,7 @@ function _installFields2(uaVariable: UAVariableImpl, { get, set }: {
         propertyNode.$dataValue.serverPicoseconds = uaVariable.$dataValue.serverPicoseconds;
         propertyNode.$dataValue.value.dataType = propertyNode.dataTypeObj.basicDataType;
         propertyNode.$dataValue.value.arrayType = propertyNode.valueRank === -1 ? VariantArrayType.Scalar : (propertyNode.valueRank === 1 ? VariantArrayType.Array : VariantArrayType.Matrix)
-        propertyNode.$dataValue.value.dimensions =propertyNode.valueRank > 1 ?  propertyNode.arrayDimensions : null;
+        propertyNode.$dataValue.value.dimensions = propertyNode.valueRank > 1 ? propertyNode.arrayDimensions : null;
 
         const fieldName = field.name!;
         installDataValueGetter(propertyNode, () => get(fieldName));
@@ -398,7 +398,7 @@ function isVariableContainingExtensionObject(uaVariable: UAVariableImpl): boolea
 function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
     { get, set }: {
         get: () => ExtensionObject;
-        set: (value: ExtensionObject, sourceTimestamp: PreciseClock) => void;
+        set: (value: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => void;
     },
     options?: BindExtensionObjectOptions
 ) {
@@ -412,13 +412,7 @@ function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
     };
 
     installDataValueGetter(uaVariable, get);
-    assert(uaVariable._inner_replace_dataValue);
-    uaVariable._inner_replace_dataValue = (dataValue: DataValue, indexRange?: NumericRange | null) => {
-        /** */
-        const ext = dataValue.value.value;
-        const sourceTime = coerceClock(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
-        set(ext, sourceTime);
-    }
+    uaVariable.$set_ExtensionObject = set;
 
     _installFields2(uaVariable, {
         get: (fieldName: string) => {
@@ -436,6 +430,7 @@ function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
 }
 
 
+// eslint-disable-next-line complexity
 export function _bindExtensionObject(
     uaVariable: UAVariableImpl,
     optionalExtensionObject?: ExtensionObject,
@@ -443,10 +438,16 @@ export function _bindExtensionObject(
 ): ExtensionObject | null {
     options = options || { createMissingProp: false };
 
+    // istanbul ignore next
     if (!isVariableContainingExtensionObject(uaVariable)) {
         return null;
     }
 
+    // istanbul ignore next
+    if (optionalExtensionObject && uaVariable.valueRank === 0) {
+        warningLog(uaVariable.browseName.toString() + ": valueRank was zero but needed to be adjusted to -1 (Scalar) in bindExtensionObject");
+        uaVariable.valueRank = -1;
+    }
     const addressSpace = uaVariable.addressSpace;
     let extensionObject_;
 
@@ -567,12 +568,16 @@ const composeBrowseNameAndNodeId = (uaVariable: UAVariable, indexes: number[]) =
 }
 
 
-// eslint-disable-next-line max-statements
+// eslint-disable-next-line max-statements, complexity
 export function _bindExtensionObjectArrayOrMatrix(
     uaVariable: UAVariableImpl,
     optionalExtensionObjectArray?: ExtensionObject[],
     options?: BindExtensionObjectOptions
 ): ExtensionObject[] {
+
+    options = options || { createMissingProp: false};
+    options.createMissingProp = options.createMissingProp || false;
+
     // istanbul ignore next
     if (uaVariable.valueRank < 1) {
         throw new Error("Variable must be a MultiDimensional array");
@@ -582,6 +587,12 @@ export function _bindExtensionObjectArrayOrMatrix(
     if (!isVariableContainingExtensionObject(uaVariable)) {
         return [];
     }
+
+    if (!optionalExtensionObjectArray && uaVariable.$dataValue.value.value) {
+        assert(Array.isArray(uaVariable.$dataValue.value.value));
+        optionalExtensionObjectArray = uaVariable.$dataValue.value.value;
+    }
+    
     if ((arrayDimensions.length === 0 || arrayDimensions.length === 1 && arrayDimensions[0] === 0) && optionalExtensionObjectArray) {
         arrayDimensions[0] = optionalExtensionObjectArray.length;
     }
@@ -607,6 +618,21 @@ export function _bindExtensionObjectArrayOrMatrix(
     uaVariable.$dataValue.value.dataType = DataType.ExtensionObject;
     uaVariable.$dataValue.value.value = uaVariable.$$extensionObjectArray;
 
+
+    // make sure uaVariable.$dataValue cannot be inadvertantly changed from this point onward
+    const $dataValue = uaVariable.$dataValue;
+    Object.defineProperty(uaVariable, "$dataValue", {
+        get(): DataValue {
+            return $dataValue;
+        },
+        set() {
+            throw new Error("$dataValue is now sealed , you should not change internal $dataValue!");
+        },
+        //    writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+
     uaVariable.bindVariable({
         get: () => uaVariable.$dataValue.value
     }, true);
@@ -620,10 +646,13 @@ export function _bindExtensionObjectArrayOrMatrix(
 
         const { browseName, nodeId } = composeBrowseNameAndNodeId(uaVariable, index);
 
-
-
         let uaElement = uaVariable.getComponentByName(browseName) as UAVariableImpl | null;
         if (!uaElement) {
+
+            if (!options.createMissingProp) {
+                continue;
+            }
+            
             uaElement = namespace.addVariable({
                 browseName,
                 nodeId,
@@ -634,7 +663,6 @@ export function _bindExtensionObjectArrayOrMatrix(
             }) as UAVariableImpl;
         }
 
-        uaElement.$dataValue.value.dataType = DataType.ExtensionObject;
         uaElement.$dataValue.statusCode = StatusCodes.Good;
         uaElement.$dataValue.sourceTimestamp = uaVariable.$dataValue.sourceTimestamp;
         uaElement.$dataValue.sourcePicoseconds = uaVariable.$dataValue.sourcePicoseconds;
@@ -645,16 +673,21 @@ export function _bindExtensionObjectArrayOrMatrix(
 
         {
             const capturedIndex = i;
+            const capturedUaElement = uaElement as UAVariableImpl;
             _innerBindExtensionObjectScalar(uaElement,
                 {
                     get: () => uaVariable.$$extensionObjectArray[capturedIndex],
-                    set: (newValue: ExtensionObject, sourceTimestamp: PreciseClock) => {
-                        uaVariable.$$extensionObjectArray[capturedIndex] = newValue;
-                        uaVariable.touchValue();
-                        propagateTouchValueDownward(uaVariable, sourceTimestamp);
-                        propagateTouchValueUpward(uaVariable, sourceTimestamp);
-                    },
+                    set: (newValue: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => {
 
+                        assert(!isProxy(uaVariable.$$extensionObjectArray[capturedIndex]));
+                        uaVariable.$$extensionObjectArray[capturedIndex] = newValue;
+                        if (uaVariable.$$extensionObjectArray !== uaVariable.$dataValue.value.value) {
+                            console.log("uaVariable", uaVariable.nodeId.toString());
+                            console.log("Houston! We have a problem ");
+                        }
+                        propagateTouchValueDownward(capturedUaElement, sourceTimestamp, cache);
+                        propagateTouchValueUpward(capturedUaElement, sourceTimestamp, cache);
+                    }
                 }, { ...options, force: true });
 
         }
@@ -717,3 +750,23 @@ export function extractPartialData(path: string | string[], extensionObject: Ext
     c1[name] = c2[name];
     return partialData;
 }
+
+export function propagateTouchValueDownwardArray(uaVariable: UAVariableImpl, now: PreciseClock, cache: Set<UAVariable>) {
+
+    if (!uaVariable.$$extensionObjectArray) return;
+    const arrayDimensions = uaVariable.arrayDimensions || [];
+    const totalLength = uaVariable.$$extensionObjectArray.length;
+
+    const indexIterator = new IndexIterator(arrayDimensions);
+    for (let i = 0; i < totalLength; i++) {
+
+        const index = indexIterator.next();
+
+        const { browseName, nodeId } = composeBrowseNameAndNodeId(uaVariable, index);
+        const uaElement = uaVariable.getComponentByName(browseName) as UAVariableImpl | null;
+        if (uaElement?.nodeClass === NodeClass.Variable) {
+            uaElement.touchValue(now);
+            propagateTouchValueDownward(uaElement, now, cache);
+        }
+    }
+}

package/src/ua_variable_type_impl.ts

@@ -40,6 +40,7 @@ import { _clone_children_references, ToStringBuilder, UAVariableType_toString }
 import * as tools from "./tool_isSupertypeOf";
 import { get_subtypeOfObj } from "./tool_isSupertypeOf";
 import { get_subtypeOf } from "./tool_isSupertypeOf";
+import { checkValueRankCompatibility } from "./check_value_rank_compatibility";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
@@ -50,6 +51,7 @@ const errorLog = make_errorLog(__filename);
 let doTrace = checkDebugFlag("INSTANTIATE");
 const traceLog = errorLog;
 
+
 interface InstantiateS {
     propertyOf?: any;
     componentOf?: any;
@@ -83,7 +85,17 @@ export function topMostParentIsObjectTypeOrVariableType(addressSpace: AddressSpa
     return false;
 }
 export interface UAVariableTypeOptions extends InternalBaseNodeOptions {
-    /**  */
+    /**
+     * This attribute indicates whether the Value attribute of the Variableis an array and how many dimensions the array has.
+     * It may have the following values:
+     *   * n > 1: the Value is an array with the specified number of dimensions.
+     *   * OneDimension (1): The value is an array with one dimension.
+     *   * OneOrMoreDimensions (0): The value is an array with one or more dimensions.
+     *   * Scalar (−1): The value is not an array.
+     *   * Any (−2): The value can be a scalar or an array with any number of dimensions.
+     *   * ScalarOrOneDimension (−3): The value can be a scalar or a one dimensional array.
+     *   * All DataTypes are considered to be scalar, even if they have array-like semantics like ByteString and String.
+     */
     valueRank?: number;
     arrayDimensions?: number[] | null;
     historizing?: boolean;
@@ -227,6 +239,13 @@ export class UAVariableTypeImpl extends BaseNodeImpl implements UAVariableType {
         assert(dataType instanceof NodeId);
 
         const valueRank = options.valueRank !== undefined ? options.valueRank : this.valueRank;
+
+        const { result, errorMessage } = checkValueRankCompatibility(valueRank, this.valueRank);
+        if (!result) {
+            errorLog(errorMessage);
+            throw new Error(errorMessage);
+        }
+
         const arrayDimensions = options.arrayDimensions !== undefined ? options.arrayDimensions : this.arrayDimensions;
 
         // istanbul ignore next

package/test_helpers/test_fixtures/eurange_issue.xml

@@ -18,6 +18,7 @@
         <Alias Alias="HasProperty">i=46</Alias>
         <Alias Alias="HasSubtype">i=45</Alias>
         <Alias Alias="HasTypeDefinition">i=40</Alias>
+        <Alias Alias="PropertyType">i=68</Alias>
         <Alias Alias="Int32">i=6</Alias>
         <Alias Alias="Range">i=884</Alias>
         <Alias Alias="String">i=12</Alias>
@@ -33,7 +34,7 @@
 
     <UAVariable NodeId="ns=1;i=1301" BrowseName="Range" AccessLevel="3" DataType="Range">
         <References>
-            <Reference ReferenceType="HasTypeDefinition">i=1317</Reference>
+            <Reference ReferenceType="HasTypeDefinition">ns=1;i=1317</Reference>
             <Reference ReferenceType="HasModellingRule">i=78</Reference>
         </References>
         <Value>
@@ -54,7 +55,7 @@
     <UAVariableType NodeId="ns=1;i=1317" BrowseName="MyVariableType" AccessLevel="3" DataType="Range">
         <DisplayName>EURange</DisplayName>
         <References>
-            <Reference ReferenceType="HasSubtype" IsForward="false">i=68</Reference>
+            <Reference ReferenceType="HasSubtype" IsForward="false">PropertyType</Reference>
         </References>
         <Value>
             <ExtensionObject>