node-opcua-address-space 2.59.0 → 2.62.1

package/dist/src/ua_variable_impl.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAVariableImplT = exports.UAVariableImpl = exports.verifyRankAndDimensions = exports.adjust_userAccessLevel = exports.adjust_accessLevel = void 0;
+exports.UAVariableImplT = exports.UAVariableImpl = exports.adjust_userAccessLevel = exports.adjust_accessLevel = void 0;
 /* eslint-disable max-statements */
 /* eslint-disable complexity */
 /**
@@ -10,6 +10,7 @@ exports.UAVariableImplT = exports.UAVariableImpl = exports.verifyRankAndDimensio
 // tslint:disable:no-console
 // tslint:disable:max-line-length
 const chalk = require("chalk");
+const node_opcua_address_space_base_1 = require("node-opcua-address-space-base");
 const node_opcua_assert_1 = require("node-opcua-assert");
 const node_opcua_data_model_1 = require("node-opcua-data-model");
 const node_opcua_data_value_1 = require("node-opcua-data-value");
@@ -24,6 +25,7 @@ const utils = require("node-opcua-utils");
 const node_opcua_utils_1 = require("node-opcua-utils");
 const node_opcua_variant_1 = require("node-opcua-variant");
 const session_context_1 = require("../source/session_context");
+const multiform_func_1 = require("../source/helpers/multiform_func");
 const base_node_impl_1 = require("./base_node_impl");
 const base_node_private_1 = require("./base_node_private");
 const ua_data_type_impl_1 = require("./ua_data_type_impl");
@@ -104,13 +106,13 @@ function validateDataType(addressSpace, dataTypeNodeId, variantDataType, nodeId,
     }
     let builtInType;
     let builtInUADataType;
-    const destUADataType = addressSpace.findNode(dataTypeNodeId);
+    const destUADataType = addressSpace.findDataType(dataTypeNodeId);
     (0, node_opcua_assert_1.assert)(destUADataType instanceof ua_data_type_impl_1.UADataTypeImpl);
     if (destUADataType.isAbstract || destUADataType.nodeId.namespace !== 0) {
         builtInUADataType = destUADataType;
     }
     else {
-        builtInType = node_opcua_variant_1.DataType[addressSpace.findCorrespondingBasicDataType(destUADataType)];
+        builtInType = addressSpace.findCorrespondingBasicDataType(destUADataType);
         builtInUADataType = addressSpace.findDataType(builtInType);
     }
     (0, node_opcua_assert_1.assert)(builtInUADataType instanceof ua_data_type_impl_1.UADataTypeImpl);
@@ -121,8 +123,8 @@ function validateDataType(addressSpace, dataTypeNodeId, variantDataType, nodeId,
     if (destUADataType.isSupertypeOf(enumerationUADataType)) {
         // istanbul ignore next
         if (doDebug) {
-            console.log("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
-            console.log("enumerationUADataType.", enumerationUADataType.browseName.toString(), enumerationUADataType.nodeId.toString());
+            debugLog("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
+            debugLog("enumerationUADataType.", enumerationUADataType.browseName.toString(), enumerationUADataType.nodeId.toString());
         }
         return true;
     }
@@ -134,45 +136,21 @@ function validateDataType(addressSpace, dataTypeNodeId, variantDataType, nodeId,
     if (doDebug) {
         if (dest_isSuperTypeOf_variant) {
             /* istanbul ignore next*/
-            console.log(chalk.green(" ---------- Type match !!! "), " on ", nodeId.toString());
+            debugLog(chalk.green(" ---------- Type match !!! "), " on ", nodeId.toString());
         }
         else {
             /* istanbul ignore next*/
-            console.log(chalk.red(" ---------- Type mismatch "), " on ", nodeId.toString());
+            debugLog(chalk.red(" ---------- Type mismatch "), " on ", nodeId.toString());
         }
-        console.log(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
-        console.log(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
-        console.log(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
+        debugLog(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
+        debugLog(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
+        debugLog(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
     }
     return dest_isSuperTypeOf_variant;
 }
-function verifyRankAndDimensions(options) {
-    // evaluate valueRank arrayDimensions is specified but valueRank is null
-    if (options.arrayDimensions && options.valueRank === undefined) {
-        options.valueRank = options.arrayDimensions.length;
-    }
-    options.valueRank = options.valueRank === undefined ? -1 : options.valueRank || 0; // UInt32
-    (0, node_opcua_assert_1.assert)(typeof options.valueRank === "number");
-    options.arrayDimensions = options.arrayDimensions || null;
-    (0, node_opcua_assert_1.assert)(options.arrayDimensions === null || Array.isArray(options.arrayDimensions));
-    if (options.arrayDimensions && options.valueRank <= 0) {
-        throw new Error("[CONFORMANCE] arrayDimensions must be null if valueRank <=0");
-    }
-    // specify default arrayDimension if not provided
-    if (options.valueRank > 0 && !options.arrayDimensions) {
-        options.arrayDimensions = new Array(options.valueRank).fill(0);
-    }
-    if (!options.arrayDimensions && options.valueRank > 0) {
-        throw new Error("[CONFORMANCE] arrayDimension must be specified  if valueRank >0 " + options.valueRank);
-    }
-    if (options.valueRank > 0 && options.arrayDimensions.length !== options.valueRank) {
-        throw new Error("[CONFORMANCE] when valueRank> 0, arrayDimensions must have valueRank elements, this.valueRank =" +
-            options.valueRank +
-            "  whereas arrayDimensions.length =" +
-            options.arrayDimensions.length);
-    }
+function default_func(dataValue1, callback1) {
+    return _default_writable_timestamped_set_func.call(this, dataValue1, callback1);
 }
-exports.verifyRankAndDimensions = verifyRankAndDimensions;
 /**
  * A OPCUA Variable Node
  *
@@ -203,16 +181,15 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
     constructor(options) {
         super(options);
         this.nodeClass = node_opcua_data_model_1.NodeClass.Variable;
-        verifyRankAndDimensions(options);
+        (0, node_opcua_variant_1.verifyRankAndDimensions)(options);
         this.valueRank = options.valueRank;
         this.arrayDimensions = options.arrayDimensions;
         this.dataType = this.resolveNodeId(options.dataType); // DataType (NodeId)
         this.accessLevel = adjust_accessLevel(options.accessLevel);
         this.userAccessLevel = adjust_userAccessLevel(options.userAccessLevel, this.accessLevel);
         this.minimumSamplingInterval = adjust_samplingInterval(options.minimumSamplingInterval || 0);
-        this.historizing = !!options.historizing; // coerced to boolean
-        this._dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.UncertainInitialValue, value: {} });
-        // xx options.value = options.value || { dataType: DataType.Null };
+        this.historizing = !!options.historizing; // coerced to boolean"
+        this.$dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.UncertainInitialValue, value: { dataType: node_opcua_variant_1.DataType.Null } });
         if (options.value) {
             this.bindVariable(options.value);
         }
@@ -301,10 +278,17 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         }
         if (this._timestamped_get_func) {
             if (this._timestamped_get_func.length === 0) {
-                this._dataValue = this._timestamped_get_func();
+                const dataValueOrPromise = this._timestamped_get_func();
+                if (!Object.prototype.hasOwnProperty.call(dataValueOrPromise, "then")) {
+                    this.$dataValue = dataValueOrPromise;
+                    this.verifyVariantCompatibility(this.$dataValue.value);
+                }
+                else {
+                    errorLog("Unsupported: _timestamped_get_func returns a Promise !");
+                }
             }
         }
-        let dataValue = this._dataValue;
+        let dataValue = this.$dataValue;
         if (isGoodish(dataValue.statusCode)) {
             // note : extractRange will clone the dataValue
             dataValue = (0, node_opcua_data_value_1.extractRange)(dataValue, indexRange);
@@ -342,6 +326,9 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         return dataTypeNode._getEnumerationInfo();
     }
     asyncRefresh(...args) {
+        if (isGoodish(this.$dataValue.statusCode)) {
+            this.verifyVariantCompatibility(this.$dataValue.value);
+        }
         const oldestDate = args[0];
         (0, node_opcua_assert_1.assert)(oldestDate instanceof Date);
         const callback = args[1];
@@ -358,21 +345,31 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                 return callback(null, dataValue);
             }
         }
-        if (this._dataValue.serverTimestamp && oldestDate.getTime() <= this._dataValue.serverTimestamp.getTime()) {
+        if (this.$dataValue.serverTimestamp && oldestDate.getTime() <= this.$dataValue.serverTimestamp.getTime()) {
             const dataValue = this.readValue();
             dataValue.serverTimestamp = oldestDate;
             dataValue.serverPicoseconds = 0;
             return callback(null, dataValue);
         }
-        this.refreshFunc.call(this, (err, dataValue) => {
-            if (err || !dataValue) {
-                dataValue = { statusCode: node_opcua_status_code_1.StatusCodes.BadNoDataAvailable };
-            }
-            if (dataValue !== this._dataValue) {
-                this._internal_set_dataValue(coerceDataValue(dataValue), null);
-            }
-            callback(err, this._dataValue);
-        });
+        try {
+            this.refreshFunc.call(this, (err, dataValue) => {
+                if (err || !dataValue) {
+                    errorLog("-------------- refresh call failed", this.browseName.toString(), this.nodeId.toString(), err === null || err === void 0 ? void 0 : err.message);
+                    dataValue = { statusCode: node_opcua_status_code_1.StatusCodes.BadNoDataAvailable };
+                }
+                if (dataValue !== this.$dataValue) {
+                    this._internal_set_dataValue(coerceDataValue(dataValue), null);
+                }
+                callback(err, this.$dataValue);
+            });
+        }
+        catch (err) {
+            errorLog("-------------- refresh call failed 2", this.browseName.toString(), this.nodeId.toString());
+            errorLog(err);
+            const dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadInternalError });
+            this._internal_set_dataValue(dataValue, null);
+            callback(err, this.$dataValue);
+        }
     }
     readEnumValue() {
         const value = this.readValue().value.value;
@@ -441,10 +438,80 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                 return base_node_impl_1.BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
         }
     }
-    adjustVariant(variant) {
+    getBasicDataType() {
+        if (this._basicDataType) {
+            return this._basicDataType;
+        }
+        if (this.dataType.namespace === 0 && this.dataType.value === 0) {
+            return node_opcua_variant_1.DataType.Null;
+        }
         const addressSpace = this.addressSpace;
-        const dataTypeNodeId = addressSpace.findCorrespondingBasicDataType(this.dataType);
-        return (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, dataTypeNodeId);
+        const dataTypeNode = addressSpace.findDataType(this.dataType);
+        const basicDataType = dataTypeNode ? dataTypeNode.getBasicDataType() : node_opcua_variant_1.DataType.Null;
+        // const basicDataType = addressSpace.findCorrespondingBasicDataType(this.dataType);
+        this._basicDataType = basicDataType;
+        return basicDataType;
+    }
+    adjustVariant(variant) {
+        return (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, this.getBasicDataType());
+    }
+    verifyVariantCompatibility(variant) {
+        var _a;
+        try {
+            // istanbul ignore next
+            if (Object.prototype.hasOwnProperty.call(variant, "value")) {
+                if (variant.dataType === null || variant.dataType === undefined) {
+                    throw new Error("Variant must provide a valid dataType : variant = " +
+                        variant.toString() +
+                        " this.dataType= " +
+                        this.dataType.toString());
+                }
+                if (variant.dataType === node_opcua_variant_1.DataType.Boolean &&
+                    (this.dataType.namespace !== 0 || this.dataType.value !== node_opcua_variant_1.DataType.Boolean)) {
+                    throw new Error("Variant must provide a valid Boolean : variant = " +
+                        variant.toString() +
+                        " this.dataType= " +
+                        this.dataType.toString());
+                }
+                if (this.dataType.namespace === 0 &&
+                    this.dataType.value === node_opcua_variant_1.DataType.LocalizedText &&
+                    variant.dataType !== node_opcua_variant_1.DataType.LocalizedText) {
+                    throw new Error("Variant must provide a valid LocalizedText : variant = " +
+                        variant.toString() +
+                        " this.dataType= " +
+                        this.dataType.toString());
+                }
+            }
+            const basicType = this.getBasicDataType();
+            if (basicType !== node_opcua_variant_1.DataType.Null &&
+                basicType !== node_opcua_variant_1.DataType.Variant &&
+                variant.dataType !== node_opcua_variant_1.DataType.Null &&
+                variant.dataType !== basicType) {
+                const message = "UAVariable.setValueFromSource " +
+                    this.browseName.toString() +
+                    " nodeId:" +
+                    this.nodeId.toString() +
+                    " dataType:" +
+                    this.dataType.toString() +
+                    ":\n" +
+                    "the provided variant must have the expected dataType!\n" +
+                    "   - the expected dataType is " +
+                    chalk.cyan(node_opcua_variant_1.DataType[basicType]) +
+                    "\n" +
+                    "   - the actual dataType   is " +
+                    chalk.magenta(node_opcua_variant_1.DataType[variant.dataType]) +
+                    "\n" +
+                    "   - " +
+                    variant.toString();
+                throw new Error(message);
+            }
+        }
+        catch (err) {
+            errorLog("UAVariable  ", (_a = err) === null || _a === void 0 ? void 0 : _a.message, this.browseName.toString(), " nodeId=", this.nodeId.toString());
+            errorLog(err.message);
+            errorLog(err.stack);
+            throw err;
+        }
     }
     /**
      * setValueFromSource is used to let the device sets the variable values
@@ -458,32 +525,27 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
      * @param [sourceTimestamp= Now]
      */
     setValueFromSource(variant, statusCode, sourceTimestamp) {
-        statusCode = statusCode || node_opcua_status_code_1.StatusCodes.Good;
-        // istanbul ignore next
-        if (Object.prototype.hasOwnProperty.call(variant, "value")) {
-            if (variant.dataType === null || variant.dataType === undefined) {
-                throw new Error("Variant must provide a valid dataType" + variant.toString());
-            }
-            if (variant.dataType === node_opcua_variant_1.DataType.Boolean &&
-                (this.dataType.namespace !== 0 || this.dataType.value !== node_opcua_variant_1.DataType.Boolean)) {
-                throw new Error("Variant must provide a valid Boolean" + variant.toString());
-            }
-            if (this.dataType.namespace === 0 &&
-                this.dataType.value === node_opcua_variant_1.DataType.LocalizedText &&
-                variant.dataType !== node_opcua_variant_1.DataType.LocalizedText) {
-                throw new Error("Variant must provide a valid LocalizedText" + variant.toString());
-            }
+        var _a;
+        try {
+            statusCode = statusCode || node_opcua_status_code_1.StatusCodes.Good;
+            const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+            this.verifyVariantCompatibility(variant1);
+            const now = (0, node_opcua_date_time_1.coerceClock)(sourceTimestamp, 0);
+            const dataValue = new node_opcua_data_value_1.DataValue(null);
+            dataValue.serverPicoseconds = now.picoseconds;
+            dataValue.serverTimestamp = now.timestamp;
+            dataValue.sourcePicoseconds = now.picoseconds;
+            dataValue.sourceTimestamp = now.timestamp;
+            dataValue.statusCode = statusCode;
+            dataValue.value = variant1;
+            this._internal_set_dataValue(dataValue);
+        }
+        catch (err) {
+            errorLog("UAVariable#setValueFromString Error : ", this.browseName.toString(), this.nodeId.toString());
+            errorLog(err.message);
+            errorLog((_a = this.parent) === null || _a === void 0 ? void 0 : _a.toString());
+            throw err;
         }
-        const variant1 = node_opcua_variant_1.Variant.coerce(variant);
-        const now = (0, node_opcua_date_time_1.coerceClock)(sourceTimestamp, 0);
-        const dataValue = new node_opcua_data_value_1.DataValue(null);
-        dataValue.serverPicoseconds = now.picoseconds;
-        dataValue.serverTimestamp = now.timestamp;
-        dataValue.sourcePicoseconds = now.picoseconds;
-        dataValue.sourceTimestamp = now.timestamp;
-        dataValue.statusCode = statusCode;
-        dataValue.value = variant1;
-        this._internal_set_dataValue(dataValue);
     }
     writeValue(context, dataValue, ...args) {
         context = context || session_context_1.SessionContext.defaultContext;
@@ -536,49 +598,43 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         if (statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
             return callback(null, statusCode);
         }
-        function default_func(dataValue1, indexRange1, callback1) {
-            // xx assert(!indexRange,"indexRange Not Implemented");
-            return _default_writable_timestamped_set_func.call(this, dataValue1, callback1);
-        }
-        const write_func = (this._timestamped_set_func || default_func);
+        const write_func = this._timestamped_set_func || default_func;
         if (!write_func) {
             warningLog(" warning " + this.nodeId.toString() + " " + this.browseName.toString() + " has no setter. \n");
             warningLog("Please make sure to bind the variable or to pass a valid value: new Variant({}) during construction time");
             return callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
         }
         (0, node_opcua_assert_1.assert)(write_func);
-        write_func.call(this, dataValue, indexRange, (err, statusCode1, correctedDataValue) => {
+        write_func.call(this, dataValue, (err, statusCode1) => {
             if (!err) {
-                correctedDataValue = correctedDataValue || dataValue;
-                (0, node_opcua_assert_1.assert)(correctedDataValue instanceof node_opcua_data_value_1.DataValue);
-                // xx assert(correctedDataValue.serverTimestamp);
+                dataValue && this.verifyVariantCompatibility(dataValue.value);
                 if (indexRange && !indexRange.isEmpty()) {
                     if (!indexRange.isValid()) {
                         return callback(null, node_opcua_status_code_1.StatusCodes.BadIndexRangeInvalid);
                     }
-                    const newArrayOrMatrix = correctedDataValue.value.value;
-                    if (correctedDataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
-                        if (this._dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Array) {
+                    const newArrayOrMatrix = dataValue.value.value;
+                    if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
+                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Array) {
                             return callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
                         }
                         // check that destination data is also an array
-                        (0, node_opcua_assert_1.assert)(check_valid_array(this._dataValue.value.dataType, this._dataValue.value.value));
-                        const destArr = this._dataValue.value.value;
+                        (0, node_opcua_assert_1.assert)(check_valid_array(this.$dataValue.value.dataType, this.$dataValue.value.value));
+                        const destArr = this.$dataValue.value.value;
                         const result = indexRange.set_values(destArr, newArrayOrMatrix);
                         if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
                             return callback(null, result.statusCode);
                         }
-                        correctedDataValue.value.value = result.array;
+                        dataValue.value.value = result.array;
                         // scrap original array so we detect range
-                        this._dataValue.value.value = null;
+                        this.$dataValue.value.value = null;
                     }
-                    else if (correctedDataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
-                        const dimensions = this._dataValue.value.dimensions;
-                        if (this._dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Matrix || !dimensions) {
+                    else if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
+                        const dimensions = this.$dataValue.value.dimensions;
+                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Matrix || !dimensions) {
                             // not a matrix !
                             return callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
                         }
-                        const matrix = this._dataValue.value.value;
+                        const matrix = this.$dataValue.value.value;
                         const result = indexRange.set_values_matrix({
                             matrix,
                             dimensions
@@ -586,17 +642,17 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                         if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
                             return callback(null, result.statusCode);
                         }
-                        correctedDataValue.value.dimensions = this._dataValue.value.dimensions;
-                        correctedDataValue.value.value = result.matrix;
+                        dataValue.value.dimensions = this.$dataValue.value.dimensions;
+                        dataValue.value.value = result.matrix;
                         // scrap original array so we detect range
-                        this._dataValue.value.value = null;
+                        this.$dataValue.value.value = null;
                     }
                     else {
                         return callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
                     }
                 }
                 try {
-                    this._internal_set_dataValue(correctedDataValue, indexRange);
+                    this._internal_set_dataValue(dataValue, indexRange);
                 }
                 catch (err) {
                     if (err instanceof Error) {
@@ -605,7 +661,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                     return callback(null, node_opcua_status_code_1.StatusCodes.BadInternalError);
                 }
             }
-            callback(err, statusCode1);
+            callback(err || null, statusCode1);
         });
     }
     writeAttribute(context, writeValueOptions, callback) {
@@ -656,6 +712,12 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         if (!this._validate_DataType(value.dataType)) {
             return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
         }
+        try {
+            this.verifyVariantCompatibility(value);
+        }
+        catch (err) {
+            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+        }
         return node_opcua_status_code_1.StatusCodes.Good;
     }
     /**
@@ -669,11 +731,11 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
      */
     touchValue(optionalNow) {
         const now = optionalNow || (0, node_opcua_date_time_1.getCurrentClock)();
-        this._dataValue.sourceTimestamp = now.timestamp;
-        this._dataValue.sourcePicoseconds = now.picoseconds;
-        this._dataValue.serverTimestamp = now.timestamp;
-        this._dataValue.serverPicoseconds = now.picoseconds;
-        this._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+        this.$dataValue.sourceTimestamp = now.timestamp;
+        this.$dataValue.sourcePicoseconds = now.picoseconds;
+        this.$dataValue.serverTimestamp = now.timestamp;
+        this.$dataValue.serverPicoseconds = now.picoseconds;
+        this.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
         if (this.minimumSamplingInterval === 0) {
             if (this.listenerCount("value_changed") > 0) {
                 const clonedDataValue = this.readValue();
@@ -826,8 +888,9 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             this._historyRead = _historyRead;
             (0, node_opcua_assert_1.assert)(this._historyRead.length === 6);
         }
+        // post conditions
         (0, node_opcua_assert_1.assert)(typeof this._timestamped_set_func === "function");
-        (0, node_opcua_assert_1.assert)(this._timestamped_set_func.length === 3);
+        (0, node_opcua_assert_1.assert)(this._timestamped_set_func.length === 2, "expecting 2 parameters");
     }
     readValueAsync(context, callback) {
         if (!context) {
@@ -841,7 +904,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             return;
         }
         const readImmediate = (innerCallback) => {
-            (0, node_opcua_assert_1.assert)(this._dataValue instanceof node_opcua_data_value_1.DataValue);
+            (0, node_opcua_assert_1.assert)(this.$dataValue instanceof node_opcua_data_value_1.DataValue);
             const dataValue = this.readValue();
             innerCallback(null, dataValue);
         };
@@ -895,11 +958,11 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             // check this eventNotifier: this.eventNotifier,
             // check this symbolicName: this.symbolicName,
             accessLevel: this.accessLevel, arrayDimensions: this.arrayDimensions, dataType: this.dataType, historizing: this.historizing, minimumSamplingInterval: this.minimumSamplingInterval, userAccessLevel: this.userAccessLevel, valueRank: this.valueRank });
-        const newVariable = base_node_private_1._clone.call(this, UAVariableImpl, options, optionalFilter, extraInfo);
+        const newVariable = base_node_private_1._clone.call(this, UAVariableImpl, options, optionalFilter || node_opcua_address_space_base_1.defaultCloneFilter, extraInfo || node_opcua_address_space_base_1.defaultCloneExtraInfo);
         newVariable.bindVariable();
         (0, node_opcua_assert_1.assert)(typeof newVariable._timestamped_set_func === "function");
         (0, node_opcua_assert_1.assert)(newVariable.dataType === this.dataType);
-        newVariable._dataValue = this._dataValue.clone();
+        newVariable.$dataValue = this.$dataValue.clone();
         return newVariable;
     }
     getDataTypeNode() {
@@ -919,8 +982,9 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             return true;
         }
         const addressSpace = this.addressSpace;
+        // istanbul ignore next
         if (!(extObj && extObj.constructor)) {
-            console.log(extObj);
+            errorLog(extObj);
             throw new Error("expecting an valid extension object");
         }
         const dataType = addressSpace.findDataType(this.dataType);
@@ -948,7 +1012,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             }
         }
         catch (err) {
-            console.log(err);
+            errorLog(err);
             return false;
         }
     }
@@ -957,7 +1021,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
      * @return {ExtensionObject}
      */
     bindExtensionObject(optionalExtensionObject) {
-        var _a, _b, _c;
+        var _a, _b;
         const addressSpace = this.addressSpace;
         const structure = addressSpace.findDataType("Structure");
         let extensionObject_;
@@ -968,7 +1032,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         }
         // istanbul ignore next
         if (doDebug) {
-            console.log(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
+            debugLog(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
         }
         (0, node_opcua_assert_1.assert)(structure && structure.browseName.toString() === "Structure", "expecting DataType Structure to be in IAddressSpace");
         const dt = this.getDataTypeNode();
@@ -990,8 +1054,8 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             // }
             // istanbul ignore next
             if (!this.checkExtensionObjectIsCorrect(this.$extensionObject)) {
-                console.log("on node : ", this.browseName.toString(), this.nodeId.toString(), "dataType=", this.dataType.toString({ addressSpace: this.addressSpace }));
-                console.log((_a = this.$extensionObject) === null || _a === void 0 ? void 0 : _a.toString());
+                warningLog("on node : ", this.browseName.toString(), this.nodeId.toString(), "dataType=", this.dataType.toString({ addressSpace: this.addressSpace }));
+                warningLog((_a = this.$extensionObject) === null || _a === void 0 ? void 0 : _a.toString());
                 throw new Error("bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
                     this.dataType.toString({ addressSpace: this.addressSpace }) +
                     " but we got a " +
@@ -1003,38 +1067,28 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         this.$extensionObject = optionalExtensionObject;
         // ------------------------------------------------------------------
         function prepareVariantValue(dataType, value) {
-            if (typeof dataType === "string") {
-                dataType = node_opcua_variant_1.DataType[dataType];
-            }
             if ((dataType === node_opcua_variant_1.DataType.Int32 || dataType === node_opcua_variant_1.DataType.UInt32) && value && value.key) {
                 value = value.value;
             }
             return value;
         }
-        const bindProperty = (propertyNode, name, extensionObject, dataTypeNodeId) => {
-            const dataTypeAsString = node_opcua_variant_1.DataType[dataTypeNodeId];
-            /*
-            property.setValueFromSource(new Variant({
-                dataType: dataType,
-                value: prepareVariantValue(dataType, this.$extensionObject[name])
-            }));
-             */
-            (0, node_opcua_assert_1.assert)(propertyNode.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
+        const bindProperty = (propertyNode, name, extensionObject, dataType) => {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const self = this;
             propertyNode.bindVariable({
                 timestamped_get: () => {
-                    const prop = self.$extensionObject[name];
-                    if (prop === undefined) {
-                        propertyNode._dataValue.value.dataType = node_opcua_variant_1.DataType.Null;
-                        propertyNode._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-                        propertyNode._dataValue.value.value = null;
-                        return new node_opcua_data_value_1.DataValue(propertyNode._dataValue);
+                    const propertyValue = self.$extensionObject[name];
+                    if (propertyValue === undefined) {
+                        propertyNode.$dataValue.value.dataType = node_opcua_variant_1.DataType.Null;
+                        propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+                        propertyNode.$dataValue.value.value = null;
+                        return new node_opcua_data_value_1.DataValue(propertyNode.$dataValue);
                     }
-                    const value = prepareVariantValue(dataTypeNodeId, prop);
-                    propertyNode._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-                    propertyNode._dataValue.value.value = value;
-                    return new node_opcua_data_value_1.DataValue(propertyNode._dataValue);
+                    const value = prepareVariantValue(dataType, propertyValue);
+                    propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+                    propertyNode.$dataValue.value.dataType = dataType;
+                    propertyNode.$dataValue.value.value = value;
+                    return new node_opcua_data_value_1.DataValue(propertyNode.$dataValue);
                 },
                 timestamped_set: (dataValue, callback) => {
                     dataValue;
@@ -1049,8 +1103,8 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         const s = this.readValue();
         // istanbul ignore next
         if (this.dataTypeObj.isAbstract) {
-            console.log("Warning the DataType associated with this Variable is abstract ", this.dataTypeObj.browseName.toString());
-            console.log("You need to provide a extension object yourself ");
+            warningLog("Warning the DataType associated with this Variable is abstract ", this.dataTypeObj.browseName.toString());
+            warningLog("You need to provide a extension object yourself ");
             throw new Error("bindExtensionObject requires a extensionObject as associated dataType is only abstract");
         }
         if (s.value && (s.value.dataType === node_opcua_variant_1.DataType.Null || (s.value.dataType === node_opcua_variant_1.DataType.ExtensionObject && !s.value.value))) {
@@ -1067,8 +1121,8 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             const self = this;
             this.bindVariable({
                 timestamped_get() {
-                    self._dataValue.value.value = self.$extensionObject;
-                    const d = new node_opcua_data_value_1.DataValue(self._dataValue);
+                    self.$dataValue.value.value = self.$extensionObject;
+                    const d = new node_opcua_data_value_1.DataValue(self.$dataValue);
                     d.value = new node_opcua_variant_1.Variant(d.value);
                     return d;
                 },
@@ -1090,26 +1144,28 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             (0, node_opcua_assert_1.assert)(this.checkExtensionObjectIsCorrect(this.$extensionObject));
             (0, node_opcua_assert_1.assert)(s.statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
         }
-        let property;
-        let camelCaseName;
         // ------------------------------------------------------
         // now bind each member
         // ------------------------------------------------------
-        const definition = dt._getDefinition(false);
+        const definition = dt._getDefinition();
         // istanbul ignore next
         if (!definition) {
             throw new Error("xx definition missing in " + dt.toString());
         }
-        for (const field of definition.fields || []) {
-            camelCaseName = (0, node_opcua_utils_1.lowerFirstLetter)(field.name);
-            const component = components.filter((f) => f.browseName.name.toString() === field.name);
-            if (component.length === 1) {
-                property = component[0];
+        const getOrCreateProperty = (field) => {
+            let property;
+            const selectedComponents = components.filter((f) => f instanceof UAVariableImpl && f.browseName.name.toString() === field.name);
+            if (field.dataType.value === node_opcua_variant_1.DataType.Variant) {
+                warningLog("Warning : variant is not supported in ExtensionObject");
+            }
+            if (selectedComponents.length === 1) {
+                property = selectedComponents[0];
                 /* istanbul ignore next */
             }
             else {
+                debugLog("adding missing array variable", field.name, this.browseName.toString(), this.nodeId.toString());
                 // todo: Handle array appropriately...
-                (0, node_opcua_assert_1.assert)(component.length === 0);
+                (0, node_opcua_assert_1.assert)(selectedComponents.length === 0);
                 // create a variable (Note we may use ns=1;s=parentName/0:PropertyName)
                 property = this.namespace.addVariable({
                     browseName: { namespaceIndex: structureNamespace, name: field.name.toString() },
@@ -1119,62 +1175,64 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                 });
                 (0, node_opcua_assert_1.assert)(property.minimumSamplingInterval === this.minimumSamplingInterval);
             }
-            property._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-            property.touchValue();
+            return property;
+        };
+        for (const field of definition.fields || []) {
             if (node_opcua_nodeid_1.NodeId.sameNodeId(node_opcua_nodeid_1.NodeId.nullNodeId, field.dataType)) {
-                debugLog("field.dataType is null ! " + field.name + " " + ((_c = field.description) === null || _c === void 0 ? void 0 : _c.text));
-                debugLog(" dataType replaced with BaseDataType ");
+                warningLog("field.dataType is null ! ", field.toString(), node_opcua_nodeid_1.NodeId.nullNodeId.toString());
+                warningLog(" dataType replaced with BaseDataType ");
+                warningLog(definition.toString());
                 field.dataType = this.resolveNodeId("BaseDataType");
             }
-            const dataTypeNodeId = addressSpace.findCorrespondingBasicDataType(field.dataType);
+            const camelCaseName = (0, node_opcua_utils_1.lowerFirstLetter)(field.name);
             (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(this.$extensionObject, camelCaseName));
+            const propertyNode = getOrCreateProperty(field);
+            propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+            propertyNode.touchValue();
+            const basicDataType = addressSpace.findCorrespondingBasicDataType(field.dataType);
             // istanbul ignore next
             if (doDebug) {
                 const x = addressSpace.findNode(field.dataType).browseName.toString();
-                const basicType = addressSpace.findCorrespondingBasicDataType(field.dataType);
-                debugLog(chalk.cyan("xxx"), " dataType", w(field.dataType.toString(), 8), w(field.name, 35), "valueRank", chalk.cyan(w((0, base_node_private_1.valueRankToString)(field.valueRank), 10)), chalk.green(w(x, 25)), "basicType = ", chalk.yellow(w(basicType.toString(), 20)), property.nodeId.toString(), property.readValue().statusCode.toString());
+                debugLog(chalk.cyan("xxx"), " dataType", w(field.dataType.toString(), 8), w(field.name, 35), "valueRank", chalk.cyan(w((0, base_node_private_1.valueRankToString)(field.valueRank), 10)), chalk.green(w(x, 25)), "basicType = ", chalk.yellow(w(basicDataType.toString(), 20)), propertyNode.nodeId.toString(), propertyNode.readValue().statusCode.toString());
             }
-            if (this.$extensionObject[camelCaseName] !== undefined && dataTypeNodeId === node_opcua_variant_1.DataType.ExtensionObject) {
+            if (this.$extensionObject[camelCaseName] !== undefined && basicDataType === node_opcua_variant_1.DataType.ExtensionObject) {
                 (0, node_opcua_assert_1.assert)(this.$extensionObject[camelCaseName] instanceof Object);
-                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(property));
-                property._dataValue.value = new node_opcua_variant_1.Variant({
+                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(propertyNode));
+                propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
                     dataType: node_opcua_variant_1.DataType.ExtensionObject,
                     value: this.$extensionObject[camelCaseName]
-                });
-                property.bindExtensionObject();
-                property.$extensionObject = this.$extensionObject[camelCaseName];
+                }));
+                propertyNode.bindExtensionObject();
+                propertyNode.$extensionObject = this.$extensionObject[camelCaseName];
             }
             else {
-                const dataTypeAsString = node_opcua_variant_1.DataType[dataTypeNodeId];
-                (0, node_opcua_assert_1.assert)(typeof dataTypeAsString === "string");
                 const prop = this.$extensionObject[camelCaseName];
                 if (prop === undefined) {
-                    property._dataValue.value = new node_opcua_variant_1.Variant({
+                    propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
                         dataType: node_opcua_variant_1.DataType.Null
-                    });
+                    }));
                 }
                 else {
-                    const preparedValue = prepareVariantValue(dataTypeNodeId, prop);
-                    property._dataValue.value = new node_opcua_variant_1.Variant({
-                        dataType: dataTypeAsString,
+                    const preparedValue = prepareVariantValue(basicDataType, prop);
+                    propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
+                        dataType: basicDataType,
                         value: preparedValue
-                    });
+                    }));
                 }
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const self = this;
-                property.camelCaseName = camelCaseName;
-                property.setValueFromSource = function (variant) {
+                //  property.camelCaseName = camelCaseName;
+                propertyNode.setValueFromSource = function (variant) {
                     // eslint-disable-next-line @typescript-eslint/no-this-alias
                     const inner_this = this;
-                    variant = node_opcua_variant_1.Variant.coerce(variant);
-                    // xx console.log("PropertySetValueFromSource this", inner_this.nodeId.toString(), inner_this.browseName.toString(), variant.toString(), inner_this.dataType.toString());
-                    // xx assert(variant.dataType === this.dataType);
-                    self.$extensionObject[inner_this.camelCaseName] = variant.value;
+                    const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+                    inner_this.verifyVariantCompatibility(variant1);
+                    self.$extensionObject[camelCaseName] = variant1.value;
                     self.touchValue();
                 };
             }
-            (0, node_opcua_assert_1.assert)(property.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
-            bindProperty(property, camelCaseName, this.$extensionObject, dataTypeNodeId);
+            (0, node_opcua_assert_1.assert)(propertyNode.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
+            bindProperty(propertyNode, camelCaseName, this.$extensionObject, basicDataType);
         }
         (0, node_opcua_assert_1.assert)(this.$extensionObject instanceof Object);
         return this.$extensionObject;
@@ -1211,7 +1269,6 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         name = path[path.length - 1];
         c1[name] = c2[name];
         c1[name] += 1;
-        // xx console.log(partialData);
         setExtensionObjectValue(this, partialData);
     }
     constructExtensionObjectFromComponents() {
@@ -1261,10 +1318,16 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
     _validate_DataType(variantDataType) {
         return validateDataType(this.addressSpace, this.dataType, variantDataType, this.nodeId, /* allow Nulls */ false);
     }
+    _internal_set_value(value) {
+        if (value.dataType !== node_opcua_variant_1.DataType.Null) {
+            this.verifyVariantCompatibility(value);
+        }
+        this.$dataValue.value = value;
+    }
     _internal_set_dataValue(dataValue, indexRange) {
         (0, node_opcua_assert_1.assert)(dataValue, "expecting a dataValue");
         (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue, "expecting dataValue to be a DataValue");
-        (0, node_opcua_assert_1.assert)(dataValue !== this._dataValue, "expecting dataValue to be different from previous DataValue instance");
+        (0, node_opcua_assert_1.assert)(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
         if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
@@ -1283,23 +1346,26 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         // istanbul ignore next
         if (this.dataType.namespace === 0) {
             if (this.dataType.value === node_opcua_variant_1.DataType.LocalizedText && dataValue.value.dataType !== node_opcua_variant_1.DataType.LocalizedText) {
-                throw new Error("Invalid dataValue provided (expecting a LocalizedText) but got " + dataValue.toString());
+                const message = "Invalid dataValue provided (expecting a LocalizedText) but got " + dataValue.toString();
+                errorLog(message);
+                throw new Error(message);
             }
         }
-        const old_dataValue = this._dataValue;
-        this._dataValue = dataValue;
-        this._dataValue.statusCode = this._dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
+        this.verifyVariantCompatibility(dataValue.value);
+        const old_dataValue = this.$dataValue;
+        this.$dataValue = dataValue;
+        this.$dataValue.statusCode = this.$dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
         // repair missing timestamps
         if (!dataValue.serverTimestamp) {
-            this._dataValue.serverTimestamp = old_dataValue.serverTimestamp;
-            this._dataValue.serverPicoseconds = old_dataValue.serverPicoseconds;
+            this.$dataValue.serverTimestamp = old_dataValue.serverTimestamp;
+            this.$dataValue.serverPicoseconds = old_dataValue.serverPicoseconds;
         }
         if (!dataValue.sourceTimestamp) {
-            this._dataValue.sourceTimestamp = old_dataValue.sourceTimestamp;
-            this._dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds;
+            this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp;
+            this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds;
         }
         if (!(0, node_opcua_data_value_1.sameDataValue)(old_dataValue, dataValue)) {
-            this.emit("value_changed", this._dataValue, indexRange);
+            this.emit("value_changed", this.$dataValue, indexRange);
         }
     }
     _conditionRefresh(_cache) {
@@ -1467,7 +1533,7 @@ function _calculateEffectiveUserAccessLevelFromPermission(node, context, userAcc
 function adjustVariant2(variant) {
     // convert Variant( Scalar|ByteString) =>  Variant(Array|ByteArray)
     const addressSpace = this.addressSpace;
-    const basicType = addressSpace.findCorrespondingBasicDataType(this.dataType);
+    const basicType = this.getBasicDataType();
     variant = (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, basicType);
     return variant;
 }
@@ -1476,7 +1542,6 @@ function _not_writable_timestamped_set_func(dataValue, callback) {
     callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable, null);
 }
 function _default_writable_timestamped_set_func(dataValue, callback) {
-    /* jshint validthis: true */
     (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
     callback(null, node_opcua_status_code_1.StatusCodes.Good, dataValue);
 }
@@ -1511,7 +1576,7 @@ function _Variable_bind_with_async_refresh(options) {
     (0, node_opcua_assert_1.assert)(!this.refreshFunc);
     this.refreshFunc = options.refreshFunc;
     // assert(this.readValue().statusCode === StatusCodes.BadNodeIdUnknown);
-    this._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.UncertainInitialValue;
+    this.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.UncertainInitialValue;
     // TO DO : REVISIT THIS ASSUMPTION
     if (false && this.minimumSamplingInterval === 0) {
         // when a getter /timestamped_getter or async_getter is provided
@@ -1530,13 +1595,17 @@ function _Variable_bind_with_timestamped_get(options) {
     const async_refresh_func = (callback) => {
         Promise.resolve(this._timestamped_get_func.call(this))
             .then((dataValue) => callback(null, dataValue))
-            .catch((err) => callback(err));
+            .catch((err) => {
+            errorLog("asyncRefresh error: Variable is  ", this.nodeId.toString(), this.browseName.toString());
+            callback(err);
+        });
     };
+    const pThis = this;
     if (options.timestamped_get.length === 0) {
         const timestamped_get = options.timestamped_get;
         // sync version | Promise version
         this._timestamped_get_func = timestamped_get;
-        const dataValue_verify = timestamped_get.call(this);
+        const dataValue_verify = timestamped_get.call(pThis);
         // dataValue_verify should be a DataValue or a Promise
         /* istanbul ignore next */
         if (!(dataValue_verify instanceof node_opcua_data_value_1.DataValue) && typeof dataValue_verify.then !== "function") {
@@ -1575,16 +1644,14 @@ function _Variable_bind_with_simple_get(options) {
             return new node_opcua_data_value_1.DataValue({ statusCode: value });
         }
         else {
-            if (!this._dataValue || !isGoodish(this._dataValue.statusCode) || !(0, node_opcua_variant_1.sameVariant)(this._dataValue.value, value)) {
+            if (!this.$dataValue || !isGoodish(this.$dataValue.statusCode) || !(0, node_opcua_variant_1.sameVariant)(this.$dataValue.value, value)) {
                 this.setValueFromSource(value, node_opcua_status_code_1.StatusCodes.Good);
             }
-            else {
-                // XX console.log("YYYYYYYYYYYYYYYYYYYYYYYYYY",this.browseName.toString());
-            }
-            return this._dataValue;
+            return this.$dataValue;
         }
     };
     _Variable_bind_with_timestamped_get.call(this, {
+        get: undefined,
         timestamped_get: timestamped_get_func_from__Variable_bind_with_simple_get
     });
 }
@@ -1596,12 +1663,13 @@ function _Variable_bind_with_simple_set(options) {
     (0, node_opcua_assert_1.assert)(!this._set_func);
     this._set_func = turn_sync_to_async(options.set, 1);
     (0, node_opcua_assert_1.assert)(this._set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
-    this._timestamped_set_func = (timestamped_value, indexRange, callback) => {
+    this._timestamped_set_func = (timestamped_value, callback) => {
         (0, node_opcua_assert_1.assert)(timestamped_value instanceof node_opcua_data_value_1.DataValue);
         this._set_func(timestamped_value.value, (err, statusCode) => {
+            // istanbul ignore next
             if (!err && !statusCode) {
-                console.log(chalk.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
-                console.log(chalk.yellow("StatusCode.Good is assumed"));
+                errorLog(chalk.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
+                errorLog(chalk.yellow("StatusCode.Good is assumed"));
                 return callback(err, node_opcua_status_code_1.StatusCodes.Good, timestamped_value);
             }
             callback(err, statusCode, timestamped_value);
@@ -1609,14 +1677,10 @@ function _Variable_bind_with_simple_set(options) {
     };
 }
 function _Variable_bind_with_timestamped_set(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
     (0, node_opcua_assert_1.assert)(typeof options.timestamped_set === "function");
     (0, node_opcua_assert_1.assert)(options.timestamped_set.length === 2, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){}");
     (0, node_opcua_assert_1.assert)(!options.set, "should not specify set when timestamped_set_func exists ");
-    this._timestamped_set_func = (dataValue, indexRange, callback) => {
-        // xx assert(!indexRange,"indexRange Not Implemented");
-        return options.timestamped_set.call(this, dataValue, callback);
-    };
+    this._timestamped_set_func = (0, multiform_func_1.convertToCallbackFunction1)(options.timestamped_set);
 }
 function bind_setter(options) {
     if (typeof options.set === "function") {
@@ -1626,17 +1690,22 @@ function bind_setter(options) {
     else if (typeof options.timestamped_set === "function") {
         // variation 2
         (0, node_opcua_assert_1.assert)(typeof options.timestamped_get === "function", "timestamped_set must be used with timestamped_get ");
-        _Variable_bind_with_timestamped_set.call(this, options);
+        _Variable_bind_with_timestamped_set.call(this, {
+            set: undefined,
+            timestamped_set: options.timestamped_set
+        });
     }
     else if (typeof options.timestamped_get === "function") {
         // timestamped_get is  specified but timestamped_set is not
         // => Value is read-only
         _Variable_bind_with_timestamped_set.call(this, {
+            set: undefined,
             timestamped_set: _not_writable_timestamped_set_func
         });
     }
     else {
         _Variable_bind_with_timestamped_set.call(this, {
+            set: undefined,
             timestamped_set: _default_writable_timestamped_set_func
         });
     }
@@ -1648,7 +1717,10 @@ function bind_getter(options) {
     }
     else if (typeof options.timestamped_get === "function") {
         // variation 2
-        _Variable_bind_with_timestamped_get.call(this, options);
+        _Variable_bind_with_timestamped_get.call(this, {
+            get: undefined,
+            timestamped_get: options.timestamped_get
+        });
     }
     else if (typeof options.refreshFunc === "function") {
         // variation 3