node-opcua-address-space 2.57.0 → 2.61.0

package/src/ua_variable_impl.ts

@@ -8,7 +8,19 @@
 // tslint:disable:max-line-length
 import * as chalk from "chalk";
 
-import { ContinuationData, GetFunc, SetFunc } from "node-opcua-address-space-base";
+import {
+    CloneExtraInfo,
+    ContinuationData,
+    defaultCloneExtraInfo,
+    defaultCloneFilter,
+    GetFunc,
+    SetFunc,
+    VariableDataValueGetterCallback,
+    VariableDataValueGetterPromise,
+    VariableDataValueGetterSync,
+    VariableDataValueSetterWithCallback,
+    VariableDataValueSetterWithPromise
+} from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import {
     isValidDataEncoding,
@@ -37,17 +49,25 @@ import {
     ReadProcessedDetails,
     ReadRawModifiedDetails,
     StructureDefinition,
+    StructureField,
     WriteValueOptions
 } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { Variant, VariantLike, DataType, sameVariant, VariantArrayType, adjustVariant } from "node-opcua-variant";
+import {
+    Variant,
+    VariantLike,
+    DataType,
+    sameVariant,
+    VariantArrayType,
+    adjustVariant,
+    verifyRankAndDimensions
+} from "node-opcua-variant";
 import { StatusCodeCallback } from "node-opcua-status-code";
 import {
     IAddressSpace,
     BindVariableOptions,
     ContinuationPoint,
-    DataValueCallback,
     IVariableHistorian,
     TimestampGetFunc,
     TimestampSetFunc,
@@ -56,7 +76,6 @@ import {
     UAVariableType,
     CloneOptions,
     CloneFilter,
-    CloneExtraInfo,
     ISessionContext,
     BaseNode,
     UAVariableT
@@ -64,6 +83,7 @@ import {
 import { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
 
 import { SessionContext } from "../source/session_context";
+import { convertToCallbackFunction1 } from "../source/helpers/multiform_func";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private";
 import { EnumerationInfo, IEnumItem, UADataTypeImpl } from "./ua_data_type_impl";
@@ -162,16 +182,16 @@ function validateDataType(
     if (variantDataType === DataType.Null && !allowNulls) {
         return false;
     }
-    let builtInType: string;
+    let builtInType: DataType;
     let builtInUADataType: UADataType;
 
-    const destUADataType = addressSpace.findNode(dataTypeNodeId) as UADataType;
+    const destUADataType = addressSpace.findDataType(dataTypeNodeId)!;
     assert(destUADataType instanceof UADataTypeImpl);
 
     if (destUADataType.isAbstract || destUADataType.nodeId.namespace !== 0) {
         builtInUADataType = destUADataType;
     } else {
-        builtInType = DataType[addressSpace.findCorrespondingBasicDataType(destUADataType)];
+        builtInType = addressSpace.findCorrespondingBasicDataType(destUADataType);
         builtInUADataType = addressSpace.findDataType(builtInType)!;
     }
     assert(builtInUADataType instanceof UADataTypeImpl);
@@ -183,8 +203,8 @@ function validateDataType(
     if (destUADataType.isSupertypeOf(enumerationUADataType)) {
         // istanbul ignore next
         if (doDebug) {
-            console.log("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
-            console.log(
+            debugLog("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
+            debugLog(
                 "enumerationUADataType.",
                 enumerationUADataType.browseName.toString(),
                 enumerationUADataType.nodeId.toString()
@@ -203,19 +223,23 @@ function validateDataType(
     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 default_func(this: UAVariable, dataValue1: DataValue, callback1: CallbackT<StatusCode>) {
+    return _default_writable_timestamped_set_func.call(this, dataValue1, callback1);
+}
+
 interface UAVariableOptions extends InternalBaseNodeOptions {
     value?: any;
     dataType: NodeId | string;
@@ -227,50 +251,6 @@ interface UAVariableOptions extends InternalBaseNodeOptions {
     historizing?: number;
 }
 
-export function verifyRankAndDimensions(options: { valueRank?: number; arrayDimensions?: number[] | null }): void {
-    // 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
-    assert(typeof options.valueRank === "number");
-
-    options.arrayDimensions = options.arrayDimensions || null;
-    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
-        );
-    }
-}
-
-type TimestampGetFunction1 = () => DataValue | Promise<DataValue>;
-type TimestampGetFunction2 = (callback: (err: Error | null, dataValue?: DataValue) => void) => void;
-type TimestampGetFunction = TimestampGetFunction1 | TimestampGetFunction2;
-
-type TimestampSetFunction1 = (this: UAVariable, dataValue: DataValue, indexRange: NumericRange) => void | Promise<void>;
-type TimestampSetFunction2 = (
-    this: UAVariable,
-    dataValue: DataValue,
-    indexRange: NumericRange,
-    callback: (err: Error | null, StatusCode: StatusCode) => void
-) => void;
-type TimestampSetFunction = TimestampSetFunction1 | TimestampSetFunction2;
-
 /**
  * A OPCUA Variable Node
  *
@@ -299,7 +279,9 @@ type TimestampSetFunction = TimestampSetFunction1 | TimestampSetFunction2;
  */
 export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     public readonly nodeClass = NodeClass.Variable;
+
     public dataType: NodeId;
+    private _basicDataType?: DataType;
 
     public $extensionObject?: any;
 
@@ -307,9 +289,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     public varHistorian?: IVariableHistorian;
 
     /**
-     * @internal
+     * @internal @private
      */
-    public _dataValue: DataValue;
+    public $dataValue: DataValue;
     public accessLevel: number;
     public userAccessLevel?: number;
     public valueRank: number;
@@ -318,11 +300,11 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     public semantic_version: number;
     public arrayDimensions: null | number[];
 
-    public _timestamped_get_func?: TimestampGetFunction | null;
-    public _timestamped_set_func?: TimestampSetFunction | null;
+    public _timestamped_get_func?: TimestampGetFunc | null;
+    public _timestamped_set_func?: VariableDataValueSetterWithCallback | null;
     public _get_func: any;
     public _set_func: any;
-    public refreshFunc?: (callback: DataValueCallback) => void;
+    public refreshFunc?: (callback: CallbackT<DataValue>) => void;
     public __waiting_callbacks?: any[];
 
     get typeDefinitionObj(): UAVariableType {
@@ -346,11 +328,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         this.minimumSamplingInterval = adjust_samplingInterval(options.minimumSamplingInterval || 0);
 
-        this.historizing = !!options.historizing; // coerced to boolean
+        this.historizing = !!options.historizing; // coerced to boolean"
 
-        this._dataValue = new DataValue({ statusCode: StatusCodes.UncertainInitialValue, value: {} });
-
-        // xx options.value = options.value || { dataType: DataType.Null };
+        this.$dataValue = new DataValue({ statusCode: StatusCodes.UncertainInitialValue, value: { dataType: DataType.Null } });
 
         if (options.value) {
             this.bindVariable(options.value);
@@ -453,11 +433,17 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         if (this._timestamped_get_func) {
             if (this._timestamped_get_func.length === 0) {
-                this._dataValue = (this._timestamped_get_func as TimestampGetFunction1)() as DataValue;
+                const dataValueOrPromise = (this._timestamped_get_func as VariableDataValueGetterSync)();
+                if (!Object.prototype.hasOwnProperty.call(dataValueOrPromise, "then")) {
+                    this.$dataValue = dataValueOrPromise as DataValue;
+                    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
@@ -504,12 +490,14 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         return dataTypeNode._getEnumerationInfo();
     }
 
-    public asyncRefresh(oldestDate: Date, callback: DataValueCallback): void;
+    public asyncRefresh(oldestDate: Date, callback: CallbackT<DataValue>): void;
     public asyncRefresh(oldestDate: Date): Promise<DataValue>;
     public asyncRefresh(...args: any[]): any {
+        this.verifyVariantCompatibility(this.$dataValue.value);
+
         const oldestDate = args[0] as Date;
         assert(oldestDate instanceof Date);
-        const callback = args[1] as DataValueCallback;
+        const callback = args[1] as CallbackT<DataValue>;
 
         if (!this.refreshFunc) {
             // no refresh func
@@ -524,22 +512,36 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             }
         }
 
-        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: Error | null, dataValue?: DataValueLike) => {
-            if (err || !dataValue) {
-                dataValue = { statusCode: StatusCodes.BadNoDataAvailable };
-            }
-            if (dataValue !== this._dataValue) {
-                this._internal_set_dataValue(coerceDataValue(dataValue), null);
-            }
-            callback(err, this._dataValue);
-        });
+        try {
+            this.refreshFunc.call(this, (err: Error | null, dataValue?: DataValueLike) => {
+                if (err || !dataValue) {
+                    errorLog(
+                        "-------------- refresh call failed",
+                        this.browseName.toString(),
+                        this.nodeId.toString(),
+                        err?.message
+                    );
+                    dataValue = { statusCode: 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 DataValue({ statusCode: StatusCodes.BadInternalError });
+            this._internal_set_dataValue(dataValue, null);
+            callback(err as Error, this.$dataValue);
+        }
     }
 
     public readEnumValue(): IEnumItem {
@@ -629,10 +631,91 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         }
     }
 
-    public adjustVariant(variant: Variant): Variant {
+    public getBasicDataType(): DataType {
+        if (this._basicDataType) {
+            return this._basicDataType;
+        }
+        if (this.dataType.namespace === 0 && this.dataType.value === 0) {
+            return DataType.Null;
+        }
         const addressSpace = this.addressSpace;
-        const dataTypeNodeId = addressSpace.findCorrespondingBasicDataType(this.dataType);
-        return adjustVariant(variant, this.valueRank, dataTypeNodeId);
+        const dataTypeNode = addressSpace.findDataType(this.dataType)!;
+        const basicDataType = dataTypeNode ? dataTypeNode.getBasicDataType() : DataType.Null;
+        // const basicDataType = addressSpace.findCorrespondingBasicDataType(this.dataType);
+        this._basicDataType = basicDataType;
+        return basicDataType;
+    }
+    public adjustVariant(variant: Variant): Variant {
+        return adjustVariant(variant, this.valueRank, this.getBasicDataType());
+    }
+    public verifyVariantCompatibility(variant: Variant): void {
+        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 === DataType.Boolean &&
+                    (this.dataType.namespace !== 0 || this.dataType.value !== 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 === DataType.LocalizedText &&
+                    variant.dataType !== 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 !== DataType.Null &&
+                basicType !== DataType.Variant &&
+                variant.dataType !== 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(DataType[basicType]) +
+                    "\n" +
+                    "   - the actual dataType   is " +
+                    chalk.magenta(DataType[variant.dataType]) +
+                    "\n" +
+                    "   - " +
+                    variant.toString();
+                throw new Error(message);
+            }
+        } catch (err) {
+            errorLog("UAVariable  ", (err as Error)?.message, this.browseName.toString(), " nodeId=", this.nodeId.toString());
+            errorLog((err as Error).message);
+            errorLog((err as Error).stack);
+            throw err;
+        }
     }
     /**
      * setValueFromSource is used to let the device sets the variable values
@@ -646,39 +729,26 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
      * @param [sourceTimestamp= Now]
      */
     public setValueFromSource(variant: VariantLike, statusCode?: StatusCode, sourceTimestamp?: Date): void {
-        statusCode = statusCode || 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 === DataType.Boolean &&
-                (this.dataType.namespace !== 0 || this.dataType.value !== DataType.Boolean)
-            ) {
-                throw new Error("Variant must provide a valid Boolean" + variant.toString());
-            }
-            if (
-                this.dataType.namespace === 0 &&
-                this.dataType.value === DataType.LocalizedText &&
-                variant.dataType !== DataType.LocalizedText
-            ) {
-                throw new Error("Variant must provide a valid LocalizedText" + variant.toString());
-            }
+        try {
+            statusCode = statusCode || StatusCodes.Good;
+            const variant1 = Variant.coerce(variant);
+            this.verifyVariantCompatibility(variant1);
+            const now = coerceClock(sourceTimestamp, 0);
+
+            const dataValue = new 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 as Error).message);
+            errorLog(this.parent?.toString());
+            throw err;
         }
-
-        const variant1 = Variant.coerce(variant);
-
-        const now = coerceClock(sourceTimestamp, 0);
-
-        const dataValue = new 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);
     }
 
     public writeValue(
@@ -749,16 +819,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             return callback!(null, statusCode);
         }
 
-        function default_func(
-            this: UAVariable,
-            dataValue1: DataValue,
-            indexRange1: NumericRange,
-            callback1: (err: Error | null, statusCode: StatusCode, dataValue?: DataValue | null | undefined) => void
-        ) {
-            // 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) as any;
+        const write_func = this._timestamped_set_func || default_func;
 
         if (!write_func) {
             warningLog(" warning " + this.nodeId.toString() + " " + this.browseName.toString() + " has no setter. \n");
@@ -767,77 +828,70 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         }
         assert(write_func);
 
-        write_func.call(
-            this,
-            dataValue,
-            indexRange,
-            (err: Error | null, statusCode1?: StatusCode, correctedDataValue?: DataValue) => {
-                if (!err) {
-                    correctedDataValue = correctedDataValue || dataValue;
-                    assert(correctedDataValue instanceof DataValue);
-                    // xx assert(correctedDataValue.serverTimestamp);
-
-                    if (indexRange && !indexRange.isEmpty()) {
-                        if (!indexRange.isValid()) {
-                            return callback!(null, StatusCodes.BadIndexRangeInvalid);
+        write_func.call(this, dataValue, (err?: Error | null, statusCode1?: StatusCode) => {
+            if (!err) {
+                dataValue && this.verifyVariantCompatibility(dataValue.value);
+
+                if (indexRange && !indexRange.isEmpty()) {
+                    if (!indexRange.isValid()) {
+                        return callback!(null, StatusCodes.BadIndexRangeInvalid);
+                    }
+
+                    const newArrayOrMatrix = dataValue.value.value;
+
+                    if (dataValue.value.arrayType === VariantArrayType.Array) {
+                        if (this.$dataValue.value.arrayType !== VariantArrayType.Array) {
+                            return callback(null, StatusCodes.BadTypeMismatch);
                         }
+                        // check that destination data is also an array
+                        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);
 
-                        const newArrayOrMatrix = correctedDataValue.value.value;
-
-                        if (correctedDataValue.value.arrayType === VariantArrayType.Array) {
-                            if (this._dataValue.value.arrayType !== VariantArrayType.Array) {
-                                return callback(null, StatusCodes.BadTypeMismatch);
-                            }
-                            // check that destination data is also an array
-                            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(StatusCodes.Good)) {
-                                return callback!(null, result.statusCode);
-                            }
-                            correctedDataValue.value.value = result.array;
-
-                            // scrap original array so we detect range
-                            this._dataValue.value.value = null;
-                        } else if (correctedDataValue.value.arrayType === VariantArrayType.Matrix) {
-                            const dimensions = this._dataValue.value.dimensions;
-                            if (this._dataValue.value.arrayType !== VariantArrayType.Matrix || !dimensions) {
-                                // not a matrix !
-                                return callback!(null, StatusCodes.BadTypeMismatch);
-                            }
-                            const matrix = this._dataValue.value.value;
-                            const result = indexRange.set_values_matrix(
-                                {
-                                    matrix,
-                                    dimensions
-                                },
-                                newArrayOrMatrix
-                            );
-                            if (result.statusCode.isNot(StatusCodes.Good)) {
-                                return callback!(null, result.statusCode);
-                            }
-                            correctedDataValue.value.dimensions = this._dataValue.value.dimensions;
-                            correctedDataValue.value.value = result.matrix;
-
-                            // scrap original array so we detect range
-                            this._dataValue.value.value = null;
-                        } else {
+                        if (result.statusCode.isNot(StatusCodes.Good)) {
+                            return callback!(null, result.statusCode);
+                        }
+                        dataValue.value.value = result.array;
+
+                        // scrap original array so we detect range
+                        this.$dataValue.value.value = null;
+                    } else if (dataValue.value.arrayType === VariantArrayType.Matrix) {
+                        const dimensions = this.$dataValue.value.dimensions;
+                        if (this.$dataValue.value.arrayType !== VariantArrayType.Matrix || !dimensions) {
+                            // not a matrix !
                             return callback!(null, StatusCodes.BadTypeMismatch);
                         }
-                    }
-                    try {
-                        this._internal_set_dataValue(correctedDataValue, indexRange);
-                    } catch (err) {
-                        if (err instanceof Error) {
-                            warningLog(err.message);
+                        const matrix = this.$dataValue.value.value;
+                        const result = indexRange.set_values_matrix(
+                            {
+                                matrix,
+                                dimensions
+                            },
+                            newArrayOrMatrix
+                        );
+                        if (result.statusCode.isNot(StatusCodes.Good)) {
+                            return callback!(null, result.statusCode);
                         }
-                        return callback!(null, StatusCodes.BadInternalError);
+                        dataValue.value.dimensions = this.$dataValue.value.dimensions;
+                        dataValue.value.value = result.matrix;
+
+                        // scrap original array so we detect range
+                        this.$dataValue.value.value = null;
+                    } else {
+                        return callback!(null, StatusCodes.BadTypeMismatch);
+                    }
+                }
+                try {
+                    this._internal_set_dataValue(dataValue, indexRange);
+                } catch (err) {
+                    if (err instanceof Error) {
+                        warningLog(err.message);
                     }
+                    return callback!(null, StatusCodes.BadInternalError);
                 }
-                callback!(err, statusCode1);
             }
-        );
+            callback!(err || null, statusCode1);
+        });
     }
 
     public writeAttribute(context: ISessionContext | null, writeValue: WriteValueOptions, callback: StatusCodeCallback): void;
@@ -903,6 +957,11 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         if (!this._validate_DataType(value.dataType)) {
             return StatusCodes.BadTypeMismatch;
         }
+        try {
+            this.verifyVariantCompatibility(value);
+        } catch (err) {
+            return StatusCodes.BadTypeMismatch;
+        }
         return StatusCodes.Good;
     }
 
@@ -917,12 +976,12 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
      */
     public touchValue(optionalNow?: PreciseClock): void {
         const now = optionalNow || getCurrentClock();
-        this._dataValue.sourceTimestamp = now.timestamp;
-        this._dataValue.sourcePicoseconds = now.picoseconds;
-        this._dataValue.serverTimestamp = now.timestamp;
-        this._dataValue.serverPicoseconds = now.picoseconds;
+        this.$dataValue.sourceTimestamp = now.timestamp;
+        this.$dataValue.sourcePicoseconds = now.picoseconds;
+        this.$dataValue.serverTimestamp = now.timestamp;
+        this.$dataValue.serverPicoseconds = now.picoseconds;
 
-        this._dataValue.statusCode = StatusCodes.Good;
+        this.$dataValue.statusCode = StatusCodes.Good;
 
         if (this.minimumSamplingInterval === 0) {
             if (this.listenerCount("value_changed") > 0) {
@@ -1070,6 +1129,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         assert(typeof this._timestamped_set_func !== "function", "UAVariable already bound");
         assert(typeof this._timestamped_get_func !== "function", "UAVariable already bound");
+
         bind_getter.call(this, options);
         bind_setter.call(this, options);
 
@@ -1081,9 +1141,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             this._historyRead = _historyRead;
             assert(this._historyRead.length === 6);
         }
-
+        // post conditions
         assert(typeof this._timestamped_set_func === "function");
-        assert(this._timestamped_set_func!.length === 3);
+        assert(this._timestamped_set_func!.length === 2, "expecting 2 parameters");
     }
 
     /**
@@ -1106,7 +1166,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         }
 
         const readImmediate = (innerCallback: (err: Error | null, dataValue: DataValue) => void) => {
-            assert(this._dataValue instanceof DataValue);
+            assert(this.$dataValue instanceof DataValue);
             const dataValue = this.readValue();
             innerCallback(null, dataValue);
         };
@@ -1174,14 +1234,20 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             valueRank: this.valueRank
         };
 
-        const newVariable = _clone.call(this, UAVariableImpl, options, optionalFilter, extraInfo) as UAVariableImpl;
+        const newVariable = _clone.call(
+            this,
+            UAVariableImpl,
+            options,
+            optionalFilter || defaultCloneFilter,
+            extraInfo || defaultCloneExtraInfo
+        ) as UAVariableImpl;
 
         newVariable.bindVariable();
 
         assert(typeof newVariable._timestamped_set_func === "function");
 
         assert(newVariable.dataType === this.dataType);
-        newVariable._dataValue = this._dataValue.clone();
+        newVariable.$dataValue = this.$dataValue.clone();
         return newVariable;
     }
 
@@ -1204,8 +1270,10 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             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);
@@ -1231,7 +1299,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 return extObj.constructor.name === Constructor.name;
             }
         } catch (err) {
-            console.log(err);
+            errorLog(err);
             return false;
         }
     }
@@ -1252,7 +1320,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         // istanbul ignore next
         if (doDebug) {
-            console.log(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
+            debugLog(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
         }
         assert(structure && structure.browseName.toString() === "Structure", "expecting DataType Structure to be in IAddressSpace");
 
@@ -1277,14 +1345,14 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             // }
             // istanbul ignore next
             if (!this.checkExtensionObjectIsCorrect(this.$extensionObject!)) {
-                console.log(
+                warningLog(
                     "on node : ",
                     this.browseName.toString(),
                     this.nodeId.toString(),
                     "dataType=",
                     this.dataType.toString({ addressSpace: this.addressSpace })
                 );
-                console.log(this.$extensionObject?.toString());
+                warningLog(this.$extensionObject?.toString());
                 throw new Error(
                     "bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
                         this.dataType.toString({ addressSpace: this.addressSpace }) +
@@ -1299,45 +1367,32 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         // ------------------------------------------------------------------
 
-        function prepareVariantValue(dataType: DataType | string, value: VariantLike): VariantLike {
-            if (typeof dataType === "string") {
-                dataType = (DataType as any)[dataType];
-            }
+        function prepareVariantValue(dataType: DataType, value: VariantLike): VariantLike {
             if ((dataType === DataType.Int32 || dataType === DataType.UInt32) && value && (value as any).key) {
                 value = value.value;
             }
             return value;
         }
 
-        const bindProperty = (propertyNode: UAVariableImpl, name: any, extensionObject: any, dataTypeNodeId: any) => {
-            const dataTypeAsString = DataType[dataTypeNodeId];
-
-            /*
-            property.setValueFromSource(new Variant({
-                dataType: dataType,
-                value: prepareVariantValue(dataType, this.$extensionObject[name])
-            }));
-             */
-
-            assert(propertyNode.readValue().statusCode.equals(StatusCodes.Good));
-
+        const bindProperty = (propertyNode: UAVariableImpl, name: string, extensionObject: ExtensionObject, dataType: DataType) => {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const self = this;
             propertyNode.bindVariable(
                 {
                     timestamped_get: () => {
-                        const prop = self.$extensionObject[name];
+                        const propertyValue = self.$extensionObject[name];
 
-                        if (prop === undefined) {
-                            propertyNode._dataValue.value.dataType = DataType.Null;
-                            propertyNode._dataValue.statusCode = StatusCodes.Good;
-                            propertyNode._dataValue.value.value = null;
-                            return new DataValue(propertyNode._dataValue);
+                        if (propertyValue === undefined) {
+                            propertyNode.$dataValue.value.dataType = DataType.Null;
+                            propertyNode.$dataValue.statusCode = StatusCodes.Good;
+                            propertyNode.$dataValue.value.value = null;
+                            return new DataValue(propertyNode.$dataValue);
                         }
-                        const value = prepareVariantValue(dataTypeNodeId, prop);
-                        propertyNode._dataValue.statusCode = StatusCodes.Good;
-                        propertyNode._dataValue.value.value = value;
-                        return new DataValue(propertyNode._dataValue);
+                        const value = prepareVariantValue(dataType, propertyValue);
+                        propertyNode.$dataValue.statusCode = StatusCodes.Good;
+                        propertyNode.$dataValue.value.dataType = dataType;
+                        propertyNode.$dataValue.value.value = value;
+                        return new DataValue(propertyNode.$dataValue);
                     },
                     timestamped_set: (dataValue: DataValue, callback: CallbackT<StatusCode>) => {
                         dataValue;
@@ -1355,8 +1410,8 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         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 === DataType.Null || (s.value.dataType === DataType.ExtensionObject && !s.value.value))) {
@@ -1376,8 +1431,8 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             this.bindVariable(
                 {
                     timestamped_get() {
-                        self._dataValue.value.value = self.$extensionObject;
-                        const d = new DataValue(self._dataValue);
+                        self.$dataValue.value.value = self.$extensionObject;
+                        const d = new DataValue(self.$dataValue);
                         d.value = new Variant(d.value);
                         return d;
                     },
@@ -1386,7 +1441,6 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                         if (!self.checkExtensionObjectIsCorrect(ext)) {
                             return callback(null, StatusCodes.BadInvalidArgument);
                         }
-
                         self.$extensionObject = new Proxy(ext, makeHandler(self));
                         self.touchValue();
                         callback(null, StatusCodes.Good);
@@ -1402,51 +1456,65 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             assert(s.statusCode.equals(StatusCodes.Good));
         }
 
-        let property: any;
-        let camelCaseName: any;
         // ------------------------------------------------------
         // now bind each member
         // ------------------------------------------------------
-        const definition = dt._getDefinition(false) as StructureDefinition | null;
+        const definition = dt._getDefinition() as StructureDefinition | null;
 
         // istanbul ignore next
         if (!definition) {
             throw new Error("xx definition missing in " + dt.toString());
         }
-        for (const field of definition.fields || []) {
-            camelCaseName = lowerFirstLetter(field.name!);
-            const component = components.filter((f) => f.browseName.name!.toString() === field.name);
-            if (component.length === 1) {
-                property = component[0];
+
+        const getOrCreateProperty = (field: StructureField): UAVariableImpl => {
+            let property: UAVariableImpl;
+            const selectedComponents = components.filter(
+                (f) => f instanceof UAVariableImpl && f.browseName.name!.toString() === field.name
+            );
+
+            if (field.dataType.value === DataType.Variant) {
+                warningLog("Warning : variant is not supported in ExtensionObject");
+            }
+            if (selectedComponents.length === 1) {
+                property = selectedComponents[0] as UAVariableImpl;
                 /* istanbul ignore next */
             } else {
+                debugLog("adding missing array variable", field.name, this.browseName.toString(), this.nodeId.toString());
                 // todo: Handle array appropriately...
-                assert(component.length === 0);
+                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() },
                     componentOf: this,
                     dataType: field.dataType,
                     minimumSamplingInterval: this.minimumSamplingInterval
-                });
+                }) as UAVariableImpl;
                 assert(property.minimumSamplingInterval === this.minimumSamplingInterval);
             }
+            return property;
+        };
 
-            property._dataValue.statusCode = StatusCodes.Good;
-            property.touchValue();
-
+        for (const field of definition.fields || []) {
             if (NodeId.sameNodeId(NodeId.nullNodeId, field.dataType)) {
-                debugLog("field.dataType is null ! " + field.name + " " + field.description?.text);
-                debugLog(" dataType replaced with BaseDataType ");
+                warningLog("field.dataType is null ! ", field.toString(), NodeId.nullNodeId.toString());
+                warningLog(" dataType replaced with BaseDataType ");
+                warningLog(definition.toString());
                 field.dataType = this.resolveNodeId("BaseDataType");
             }
-            const dataTypeNodeId = addressSpace.findCorrespondingBasicDataType(field.dataType);
+
+            const camelCaseName = lowerFirstLetter(field.name!);
             assert(Object.prototype.hasOwnProperty.call(this.$extensionObject, camelCaseName));
 
+            const propertyNode = getOrCreateProperty(field);
+
+            propertyNode.$dataValue.statusCode = 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",
@@ -1456,52 +1524,56 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                     chalk.cyan(w(valueRankToString(field.valueRank), 10)),
                     chalk.green(w(x, 25)),
                     "basicType = ",
-                    chalk.yellow(w(basicType.toString(), 20)),
-                    property.nodeId.toString(),
-                    property.readValue().statusCode.toString()
+                    chalk.yellow(w(basicDataType.toString(), 20)),
+                    propertyNode.nodeId.toString(),
+                    propertyNode.readValue().statusCode.toString()
                 );
             }
-            if (this.$extensionObject[camelCaseName] !== undefined && dataTypeNodeId === DataType.ExtensionObject) {
+            if (this.$extensionObject[camelCaseName] !== undefined && basicDataType === DataType.ExtensionObject) {
                 assert(this.$extensionObject[camelCaseName] instanceof Object);
-                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(property));
-                property._dataValue.value = new Variant({
-                    dataType: DataType.ExtensionObject,
-                    value: this.$extensionObject[camelCaseName]
-                });
-                property.bindExtensionObject();
-                property.$extensionObject = this.$extensionObject[camelCaseName];
+                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(propertyNode));
+
+                propertyNode._internal_set_value(
+                    new Variant({
+                        dataType: DataType.ExtensionObject,
+                        value: this.$extensionObject[camelCaseName]
+                    })
+                );
+
+                propertyNode.bindExtensionObject();
+                propertyNode.$extensionObject = this.$extensionObject[camelCaseName];
             } else {
-                const dataTypeAsString = DataType[dataTypeNodeId];
-                assert(typeof dataTypeAsString === "string");
                 const prop = this.$extensionObject[camelCaseName];
-
                 if (prop === undefined) {
-                    property._dataValue.value = new Variant({
-                        dataType: DataType.Null
-                    });
+                    propertyNode._internal_set_value(
+                        new Variant({
+                            dataType: DataType.Null
+                        })
+                    );
                 } else {
-                    const preparedValue = prepareVariantValue(dataTypeNodeId, prop);
-                    property._dataValue.value = new Variant({
-                        dataType: dataTypeAsString,
-                        value: preparedValue
-                    });
+                    const preparedValue = prepareVariantValue(basicDataType, prop);
+                    propertyNode._internal_set_value(
+                        new Variant({
+                            dataType: basicDataType,
+                            value: preparedValue
+                        })
+                    );
                 }
 
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const self = this;
-                property.camelCaseName = camelCaseName;
-                property.setValueFromSource = function (this: any, variant: VariantLike) {
+                //  property.camelCaseName = camelCaseName;
+                propertyNode.setValueFromSource = function (this: UAVariableImpl, variant: VariantLike) {
                     // eslint-disable-next-line @typescript-eslint/no-this-alias
                     const inner_this = this;
-                    variant = 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 = Variant.coerce(variant);
+                    inner_this.verifyVariantCompatibility(variant1);
+                    self.$extensionObject[camelCaseName] = variant1.value;
                     self.touchValue();
                 };
             }
-            assert(property.readValue().statusCode.equals(StatusCodes.Good));
-            bindProperty(property, camelCaseName, this.$extensionObject, dataTypeNodeId);
+            assert(propertyNode.readValue().statusCode.equals(StatusCodes.Good));
+            bindProperty(propertyNode, camelCaseName, this.$extensionObject, basicDataType);
         }
         assert(this.$extensionObject instanceof Object);
         return this.$extensionObject;
@@ -1543,7 +1615,6 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         c1[name] = c2[name];
         c1[name] += 1;
 
-        // xx console.log(partialData);
         setExtensionObjectValue(this, partialData);
     }
 
@@ -1687,10 +1758,16 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         return validateDataType(this.addressSpace, this.dataType, variantDataType, this.nodeId, /* allow Nulls */ false);
     }
 
+    public _internal_set_value(value: Variant): void {
+        if (value.dataType !== DataType.Null) {
+            this.verifyVariantCompatibility(value);
+        }
+        this.$dataValue.value = value;
+    }
     public _internal_set_dataValue(dataValue: DataValue, indexRange?: NumericRange | null): void {
         assert(dataValue, "expecting a dataValue");
         assert(dataValue instanceof DataValue, "expecting dataValue to be a DataValue");
-        assert(dataValue !== this._dataValue, "expecting dataValue to be different from previous DataValue instance");
+        assert(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
 
         if (dataValue.value.arrayType === VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
@@ -1714,27 +1791,31 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         // istanbul ignore next
         if (this.dataType.namespace === 0) {
             if (this.dataType.value === DataType.LocalizedText && dataValue.value.dataType !== 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.verifyVariantCompatibility(dataValue.value);
 
-        this._dataValue = dataValue;
-        this._dataValue.statusCode = this._dataValue.statusCode || StatusCodes.Good;
+        const old_dataValue = this.$dataValue;
+
+        this.$dataValue = dataValue;
+        this.$dataValue.statusCode = this.$dataValue.statusCode || 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 (!sameDataValue(old_dataValue, dataValue)) {
-            this.emit("value_changed", this._dataValue, indexRange);
+            this.emit("value_changed", this.$dataValue, indexRange);
         }
     }
 
@@ -1930,10 +2011,10 @@ function _calculateEffectiveUserAccessLevelFromPermission(
     }
 }
 
-function adjustVariant2(this: UAVariable, variant: Variant): Variant {
+function adjustVariant2(this: UAVariableImpl, variant: Variant): Variant {
     // convert Variant( Scalar|ByteString) =>  Variant(Array|ByteArray)
     const addressSpace = this.addressSpace;
-    const basicType = addressSpace.findCorrespondingBasicDataType(this.dataType);
+    const basicType = this.getBasicDataType();
     variant = adjustVariant(variant, this.valueRank, basicType);
     return variant;
 }
@@ -1950,7 +2031,6 @@ function _default_writable_timestamped_set_func(
     dataValue: DataValue,
     callback: (err: Error | null, statusCode: StatusCode, dataValue?: DataValue | null) => void
 ) {
-    /* jshint validthis: true */
     assert(dataValue instanceof DataValue);
     callback(null, StatusCodes.Good, dataValue);
 }
@@ -1992,7 +2072,7 @@ function _Variable_bind_with_async_refresh(this: UAVariableImpl, options: any) {
     this.refreshFunc = options.refreshFunc;
 
     // assert(this.readValue().statusCode === StatusCodes.BadNodeIdUnknown);
-    this._dataValue.statusCode = StatusCodes.UncertainInitialValue;
+    this.$dataValue.statusCode = StatusCodes.UncertainInitialValue;
 
     // TO DO : REVISIT THIS ASSUMPTION
     if (false && this.minimumSamplingInterval === 0) {
@@ -2004,7 +2084,13 @@ function _Variable_bind_with_async_refresh(this: UAVariableImpl, options: any) {
 }
 
 // variation 2
-function _Variable_bind_with_timestamped_get(this: UAVariableImpl, options: any) {
+function _Variable_bind_with_timestamped_get(
+    this: UAVariableImpl,
+    options: {
+        get: undefined;
+        timestamped_get: TimestampGetFunc;
+    }
+) {
     /* jshint validthis: true */
     assert(this instanceof UAVariableImpl);
     assert(typeof options.timestamped_get === "function");
@@ -2012,17 +2098,20 @@ function _Variable_bind_with_timestamped_get(this: UAVariableImpl, options: any)
     assert(!this._timestamped_get_func);
 
     const async_refresh_func = (callback: (err: Error | null, dataValue?: DataValue) => void) => {
-        Promise.resolve((this._timestamped_get_func! as TimestampGetFunction1).call(this))
+        Promise.resolve((this._timestamped_get_func! as VariableDataValueGetterSync).call(this))
             .then((dataValue) => callback(null, dataValue))
-            .catch((err) => callback(err as Error));
+            .catch((err) => {
+                errorLog("asyncRefresh error: Variable is  ", this.nodeId.toString(), this.browseName.toString());
+                callback(err as Error);
+            });
     };
-
+    const pThis = this as UAVariable;
     if (options.timestamped_get.length === 0) {
-        const timestamped_get = options.timestamped_get as TimestampGetFunction1;
+        const timestamped_get = options.timestamped_get as (this: UAVariable) => DataValue | Promise<DataValue>;
         // 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 DataValue) && typeof dataValue_verify.then !== "function") {
@@ -2045,11 +2134,11 @@ function _Variable_bind_with_timestamped_get(this: UAVariableImpl, options: any)
 }
 
 // variation 1
-function _Variable_bind_with_simple_get(this: UAVariableImpl, options: any) {
+function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOptions) {
     /* jshint validthis: true */
     assert(this instanceof UAVariableImpl);
     assert(typeof options.get === "function", "should specify get function");
-    assert(options.get.length === 0, "get function should not have arguments");
+    assert(options.get!.length === 0, "get function should not have arguments");
     assert(!options.timestamped_get, "should not specify a timestamped_get function when get is specified");
     assert(!this._timestamped_get_func);
     assert(!this._get_func);
@@ -2073,16 +2162,15 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: any) {
         if (is_StatusCode(value)) {
             return new DataValue({ statusCode: value });
         } else {
-            if (!this._dataValue || !isGoodish(this._dataValue.statusCode) || !sameVariant(this._dataValue.value, value)) {
+            if (!this.$dataValue || !isGoodish(this.$dataValue.statusCode) || !sameVariant(this.$dataValue.value, value)) {
                 this.setValueFromSource(value, 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
     });
 }
@@ -2100,16 +2188,16 @@ function _Variable_bind_with_simple_set(this: UAVariableImpl, options: any) {
 
     this._timestamped_set_func = (
         timestamped_value: DataValue,
-        indexRange: NumericRange,
         callback: (err: Error | null, statusCode: StatusCode, dataValue: DataValue) => void
     ) => {
         assert(timestamped_value instanceof DataValue);
         this._set_func(timestamped_value.value, (err: Error | null, statusCode: StatusCode) => {
+            // istanbul ignore next
             if (!err && !statusCode) {
-                console.log(
+                errorLog(
                     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.yellow("StatusCode.Good is assumed"));
                 return callback(err, StatusCodes.Good, timestamped_value);
             }
             callback(err, statusCode, timestamped_value);
@@ -2117,22 +2205,20 @@ function _Variable_bind_with_simple_set(this: UAVariableImpl, options: any) {
     };
 }
 
-function _Variable_bind_with_timestamped_set(this: UAVariableImpl, options: any) {
-    assert(this instanceof UAVariableImpl);
+function _Variable_bind_with_timestamped_set(
+    this: UAVariableImpl,
+    options: {
+        timestamped_set: TimestampSetFunc;
+        set: undefined;
+    }
+) {
     assert(typeof options.timestamped_set === "function");
     assert(
         options.timestamped_set.length === 2,
         "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){}"
     );
     assert(!options.set, "should not specify set when timestamped_set_func exists ");
-    this._timestamped_set_func = (
-        dataValue: DataValue,
-        indexRange: NumericRange,
-        callback: (err: Error | null, statusCode: StatusCode, dataValue: DataValue) => void
-    ) => {
-        // xx assert(!indexRange,"indexRange Not Implemented");
-        return options.timestamped_set.call(this, dataValue, callback);
-    };
+    this._timestamped_set_func = convertToCallbackFunction1<StatusCode, DataValue, UAVariable>(options.timestamped_set);
 }
 
 interface SetterOptions {
@@ -2147,15 +2233,20 @@ function bind_setter(this: UAVariableImpl, options: SetterOptions) {
     } else if (typeof options.timestamped_set === "function") {
         // variation 2
         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
         });
     }
@@ -2164,7 +2255,7 @@ function bind_setter(this: UAVariableImpl, options: SetterOptions) {
 interface GetterOptions {
     get?: GetFunc;
     timestamped_get?: TimestampGetFunc;
-    refreshFunc?: any;
+    refreshFunc?: (callback: CallbackT<DataValue>) => void;
     dataType?: DataType | string;
     value?: any;
 }
@@ -2174,7 +2265,10 @@ function bind_getter(this: UAVariableImpl, options: GetterOptions) {
         _Variable_bind_with_simple_get.call(this, 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
         _Variable_bind_with_async_refresh.call(this, options);