node-opcua-address-space-base 2.98.0 → 2.98.2

package/dist/ua_object.d.ts

@@ -0,0 +1,131 @@
+/// <reference types="node" />
+import { NodeId } from "node-opcua-nodeid";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import { Byte, DateTime, Int16, Int32, SByte, StatusCode, UAString, UInt16, UInt32 } from "node-opcua-basic-types";
+import { LocalizedTextLike, NodeClass, QualifiedNameOptions } from "node-opcua-data-model";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { CloneOptions, CloneFilter, CloneExtraInfo } from "./clone_options";
+import { BaseNode, IPropertyAndComponentHolder } from "./base_node";
+import { UAObjectType } from "./ua_object_type";
+import { IEventData } from "./i_event_data";
+import { UAEventType } from "./ua_event_type";
+import { UAMethod } from "./ua_method";
+import { EventNotifierFlags } from "./event_notifier_flags";
+export type EventTypeLike = string | NodeId | UAEventType;
+export interface PseudoVariantNull {
+    dataType: "Null" | DataType.Null;
+}
+export interface PseudoVariantString {
+    dataType: "String" | DataType.String;
+    value: UAString;
+}
+export interface PseudoVariantStringPredefined<S extends string> {
+    dataType: "String" | DataType.String;
+    value: S;
+}
+export interface PseudoVariantBoolean {
+    dataType: "Boolean" | DataType.Boolean;
+    value: boolean;
+}
+export interface PseudoVariantDouble {
+    dataType: "Double" | DataType.Double;
+    value: number;
+}
+export interface PseudoVariantFloat {
+    dataType: "Float" | DataType.Float;
+    value: number;
+}
+export interface PseudoVariantNodeId {
+    dataType: "NodeId" | DataType.NodeId;
+    value: NodeId;
+}
+export interface PseudoVariantUInt32 {
+    dataType: "UInt32" | DataType.UInt32;
+    value: UInt32;
+}
+export interface PseudoVariantUInt16 {
+    dataType: "UInt16" | DataType.UInt16;
+    value: UInt16;
+}
+export interface PseudoVariantByte {
+    dataType: "UInt8" | DataType.Byte;
+    value: Byte;
+}
+export interface PseudoVariantInt32 {
+    dataType: "Int32" | DataType.UInt32;
+    value: Int32;
+}
+export interface PseudoVariantInt16 {
+    dataType: "Int16" | DataType.UInt16;
+    value: Int16;
+}
+export interface PseudoVariantSByte {
+    dataType: "SByte" | DataType.SByte;
+    value: SByte;
+}
+export interface PseudoVariantDateTime {
+    dataType: "DateTime" | DataType.DateTime;
+    value: DateTime;
+}
+export interface PseudoVariantLocalizedText {
+    dataType: "LocalizedText" | DataType.LocalizedText;
+    value: LocalizedTextLike;
+}
+export interface PseudoVariantDuration {
+    dataType: "Duration";
+    value: number;
+}
+export interface PseudoVariantStatusCode {
+    dataType: "StatusCode" | DataType.StatusCode;
+    value: StatusCode;
+}
+export interface PseudoVariantByteString {
+    dataType: "ByteString" | DataType.ByteString;
+    value: Buffer | null;
+}
+export interface PseudoVariantExtensionObject {
+    dataType: "ExtensionObject" | DataType.ExtensionObject;
+    value: ExtensionObject;
+}
+export interface PseudoVariantExtensionObjectArray {
+    dataType: "ExtensionObject" | DataType.ExtensionObject;
+    arrayType: VariantArrayType.Array;
+    value: ExtensionObject[];
+}
+export interface PseudoVariantVariantArray {
+    dataType: "Variant" | DataType.Variant;
+    arrayType: VariantArrayType.Array;
+    value: Variant[];
+}
+export interface PseudoVariantVariant {
+    dataType: "Variant" | DataType.Variant;
+    value: Variant;
+}
+export type PseudoVariantNumber = PseudoVariantUInt32 | PseudoVariantUInt16 | PseudoVariantByte | PseudoVariantInt32 | PseudoVariantInt16 | PseudoVariantSByte | PseudoVariantDouble | PseudoVariantFloat;
+export type PseudoVariant = PseudoVariantNull | PseudoVariantString | PseudoVariantBoolean | PseudoVariantByteString | PseudoVariantNodeId | PseudoVariantDateTime | PseudoVariantByteString | PseudoVariantDuration | PseudoVariantLocalizedText | PseudoVariantStatusCode | PseudoVariantNumber | PseudoVariantExtensionObject | PseudoVariantExtensionObjectArray | PseudoVariantVariant | PseudoVariantVariantArray;
+export interface RaiseEventData {
+    $eventDataSource?: UAEventType;
+    sourceNode?: PseudoVariantNodeId | Variant;
+    [key: string]: PseudoVariant | Variant | UAEventType | undefined;
+}
+export interface EventRaiser {
+    raiseEvent(eventType: EventTypeLike, eventData: RaiseEventData): void;
+}
+export interface UAObject extends BaseNode, EventRaiser, IPropertyAndComponentHolder {
+    readonly nodeClass: NodeClass.Object;
+    get parent(): BaseNode | null;
+    get typeDefinitionObj(): UAObjectType;
+    get typeDefinition(): NodeId;
+    readonly eventNotifier: EventNotifierFlags;
+    readonly hasMethods: boolean;
+    getFolderElementByName(browseName: QualifiedNameOptions): BaseNode | null;
+    getFolderElementByName(browseName: string, namespaceIndex?: number): BaseNode | null;
+    getMethodById(nodeId: NodeId): UAMethod | null;
+    getMethodByName(methodName: QualifiedNameOptions): UAMethod | null;
+    getMethodByName(methodName: string, namespaceIndex?: number): UAMethod | null;
+    getMethods(): UAMethod[];
+    raiseEvent(eventType: EventTypeLike | BaseNode, eventData: RaiseEventData): void;
+    on(eventName: "event", eventHandler: (eventData: IEventData) => void): this;
+    setEventNotifier(eventNotifierFlags: EventNotifierFlags): void;
+    clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAObject;
+}

package/dist/ua_object.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_object.js.map

package/dist/ua_object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_object.js","sourceRoot":"","sources":["../source/ua_object.ts"],"names":[],"mappings":""}

package/dist/ua_object_type.d.ts

@@ -0,0 +1,29 @@
+import { QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
+import { NodeClass } from "node-opcua-types";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { Byte } from "node-opcua-basic-types";
+import { InstantiateOptions } from "./instantiate_options";
+import { BaseNode, IPropertyAndComponentHolder } from "./base_node";
+import { UAObject } from "./ua_object";
+import { UAMethod } from "./ua_method";
+export interface InstantiateObjectOptions extends InstantiateOptions {
+    conditionSource?: NodeId | BaseNode | null;
+    eventNotifier?: Byte;
+    encodingOf?: NodeId | BaseNode;
+}
+export declare interface UAObjectType extends BaseNode, IPropertyAndComponentHolder {
+    readonly nodeClass: NodeClass.ObjectType;
+    readonly subtypeOf: NodeId | null;
+    readonly subtypeOfObj: UAObjectType | null;
+    readonly isAbstract: boolean;
+    readonly hasMethods: boolean;
+    isSubtypeOf(referenceType: NodeIdLike | UAObjectType): boolean;
+    /** @deprecated - use isSubtypeOf instead */
+    isSupertypeOf(referenceType: NodeIdLike | UAObjectType): boolean;
+    instantiate(options: InstantiateObjectOptions): UAObject;
+    getMethodById(nodeId: NodeId): UAMethod | null;
+    getMethodByName(methodName: QualifiedNameOptions): UAMethod | null;
+    getMethodByName(methodName: string, namespaceIndex?: number): UAMethod | null;
+    getMethodByName(methodName: QualifiedNameLike, namespaceIndex?: number): UAMethod | null;
+    getMethods(): UAMethod[];
+}

package/dist/ua_object_type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_object_type.js.map

package/dist/ua_object_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_object_type.js","sourceRoot":"","sources":["../source/ua_object_type.ts"],"names":[],"mappings":""}

package/dist/ua_property.d.ts

@@ -0,0 +1,16 @@
+import { DataType } from "node-opcua-variant";
+import { UAVariableT } from "./ua_variable_t";
+/**
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/                      |
+ * |nodeClass       |VariableType                                      |
+ * |typedDefinition |PropertyType ns=0;i=68                            |
+ * |dataType        |Null                                              |
+ * |dataType Name   |undefined ns=0;i=0                                |
+ * |isAbstract      |false                                             |
+ */
+export interface UAProperty_Base<T, DT extends DataType> {
+}
+export interface UAProperty<T, DT extends DataType> extends UAVariableT<T, /*m*/ DT>, UAProperty_Base<T, DT> {
+}

package/dist/ua_property.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_property.js.map

package/dist/ua_property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_property.js","sourceRoot":"","sources":["../source/ua_property.ts"],"names":[],"mappings":""}

package/dist/ua_reference.d.ts

@@ -0,0 +1,12 @@
+import { NodeId } from "node-opcua-nodeid";
+import { IAddressSpace } from "./address_space";
+import { BaseNode } from "./base_node";
+export interface UAReference {
+    readonly nodeId: NodeId;
+    readonly referenceType: NodeId;
+    readonly isForward: boolean;
+    readonly node?: BaseNode;
+    toString(options?: {
+        addressSpace?: IAddressSpace;
+    }): string;
+}

package/dist/ua_reference.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_reference.js.map

package/dist/ua_reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_reference.js","sourceRoot":"","sources":["../source/ua_reference.ts"],"names":[],"mappings":""}

package/dist/ua_reference_type.d.ts

@@ -0,0 +1,20 @@
+import { LocalizedText, NodeClass } from "node-opcua-data-model";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { BaseNode } from "./base_node";
+import { UAReference } from "./ua_reference";
+export declare class UAReferenceType extends BaseNode {
+    readonly nodeClass: NodeClass.ReferenceType;
+    readonly subtypeOfObj: UAReferenceType | null;
+    readonly subtypeOf: NodeId | null;
+    readonly isAbstract: boolean;
+    readonly inverseName: LocalizedText;
+    isSubtypeOf(baseType: UAReferenceType | NodeIdLike): boolean;
+    /** @deprecated - use  isSubtypeOf instead */
+    isSupertypeOf(baseType: UAReferenceType | NodeIdLike): boolean;
+    getAllSubtypes(): UAReferenceType[];
+    /**
+     *
+     * @param reference
+     */
+    checkHasSubtype(referenceType: NodeId | UAReference): boolean;
+}

package/dist/ua_reference_type.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_node_1 = require("./base_node");
+//# sourceMappingURL=ua_reference_type.js.map

package/dist/ua_reference_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_reference_type.js","sourceRoot":"","sources":["../source/ua_reference_type.ts"],"names":[],"mappings":";;AAEA,2CAAuC"}

package/dist/ua_variable.d.ts

@@ -0,0 +1,290 @@
+import { AttributeIds, CallbackT, DataType, PreciseClock, StatusCode, StatusCodeCallback, UInt32 } from "node-opcua-basic-types";
+import { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { DataValue } from "node-opcua-data-value";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { NumericRange } from "node-opcua-numeric-range";
+import { WriteValueOptions, HistoryReadDetails, HistoryReadResult, ReadRawModifiedDetails, ReadEventDetails, ReadProcessedDetails, ReadAtTimeDetails } from "node-opcua-types";
+import { VariantLike } from "node-opcua-variant";
+import { CloneOptions, CloneFilter, CloneExtraInfo } from "./clone_options";
+import { BaseNode, IPropertyAndComponentHolder } from "./base_node";
+import { ISessionContext, ContinuationData } from "./session_context";
+import { UADataType } from "./ua_data_type";
+import { UAVariableType } from "./ua_variable_type";
+import { BindVariableOptions } from "./bind_variable";
+export interface IVariableHistorian {
+    /**
+     * push a new value into the history for this variable
+     * the method should take a very small amount of time and not
+     * directly write to the underlying database
+     * @param newDataValue
+     */
+    push(newDataValue: DataValue): Promise<void>;
+    /**
+     * Extract a series of dataValue from the History database for this value
+     * @param historyReadRawModifiedDetails
+     * @param maxNumberToExtract
+     * @param isReversed
+     * @param reverseDataValue
+     * @param callback
+     */
+    extractDataValues(historyReadRawModifiedDetails: ReadRawModifiedDetails, maxNumberToExtract: number, isReversed: boolean, reverseDataValue: boolean, callback: (err: Error | null, dataValue?: DataValue[]) => void): void;
+}
+export interface IVariableHistorianOptions {
+    maxOnlineValues?: number;
+    historian?: IVariableHistorian;
+}
+export type IHistoricalDataNodeOptions = IVariableHistorianOptions | {
+    historian: IVariableHistorian;
+};
+export interface VariableAttributes {
+    dataType: NodeId;
+    valueRank: number;
+    minimumSamplingInterval: number;
+}
+export interface EnumValue2 {
+    name: string;
+    value: number;
+}
+export interface BindExtensionObjectOptions {
+    createMissingProp?: boolean;
+    force?: boolean;
+}
+export interface UAVariable extends BaseNode, VariableAttributes, IPropertyAndComponentHolder {
+    readonly nodeClass: NodeClass.Variable;
+    readonly parent: BaseNode | null;
+    readonly dataTypeObj: UADataType;
+    semantic_version: number;
+    $extensionObject?: any;
+    get typeDefinitionObj(): UAVariableType;
+    get typeDefinition(): NodeId;
+    dataType: NodeId;
+    /**
+     * returns the basic type of the variable that correspond to the dataType,
+     * that will be used in the dataValue.value.dataType property.
+     */
+    getBasicDataType(): DataType;
+    /**
+     * The **AccessLevel Attribute** is used to indicate how the Value of a Variable can be accessed
+     * (read/write) and if it contains current and/or historic data.
+     *
+     * The AccessLevel does not take any user access rights into account, i.e. although the Variable is
+     * writable this may be restricted to a certain user / user group.
+     *
+     * The {{link:AccessLevelType}}
+     */
+    accessLevel: number;
+    /**
+     * The UserAccessLevel Attribute is used to indicate how the Value of a Variable can be accessed
+     * (read/write) and if it contains current or historic data taking user access rights into account.
+     *
+     * The AccessLevelType is defined in 8.57.
+     */
+    userAccessLevel?: number;
+    /**
+     * This Attribute indicates whether the Value Attribute of the Variable is an array and how many dimensions
+     * the array has.
+     * It may have the following values:
+     *
+     *  * n > 1                     : the Value is an array with the specified number of dimensions.
+     *  * OneDimension (1):           The value is an array with one dimension.
+     *  * OneOrMoreDimensions (0):    The value is an array with one or more dimensions.
+     *  * Scalar (-1):                The value is not an array.
+     *  * Any (-2):                   The value can be a scalar or an array with any number of dimensions.
+     *  * ScalarOrOneDimension (-3):  The value can be a scalar or a one dimensional array.
+     *
+     *  NOTE:
+     *  * All DataTypes are considered to be scalar, even if they have array-like semantics like ByteString and String.
+     */
+    valueRank: number;
+    /**
+     * The MinimumSamplingInterval Attribute indicates how 'current' the Value of the Variable will
+     * be kept.
+     *
+     * It specifies (in milliseconds) how fast the Server can reasonably sample the value
+     * for changes (see Part 4 for a detailed description of sampling interval).
+     *
+     * A MinimumSamplingInterval of 0 indicates that the Server is to monitor the item continuously.
+     *
+     * A MinimumSamplingInterval of -1 means indeterminate.
+     */
+    minimumSamplingInterval: number;
+    /**
+     * This Attribute specifies the length of each dimension for an array value.
+     *
+     * - The Attribute is intended to describe the capability of the Variable, not the current size.
+     * - The number of elements shall be equal to the value of the `valueRank` Attribute.
+     * - Shall be null if `valueRank` <=0.
+     * - A value of 0 for an individual dimension indicates that the dimension has a variable length.
+     *
+     *  **example**
+     *
+     *
+     *   For example, if a Variable is defined by the following javascript array with 346 Int32 elements:
+     *
+     *   `const myArray = new Array(346).fill(0);`
+     *
+     *   then:
+     *   * `DataType` would point to an `Int32`
+     *   * the Variable's `valueRank` has the value 1 and,
+     *   * the `arrayDimensions` is an array with one entry having the value 346.
+     *
+     *  ```javascript
+     *  {
+     *    dataType: "Int32",
+     *    valueRank: 1,
+     *    arrayDimensions: [346]
+     * }
+     *  ```
+     *
+     *
+     * **Note**: the maximum length of an array transferred on the wire is 2147483647 (max Int32)
+     *     and a multidimensional array is encoded as a one dimensional array.
+     *
+     */
+    arrayDimensions: UInt32[] | null;
+    /**
+     * The `historizing` attribute indicates whether the server is actively collecting data for the
+     * history of the variable.
+     *
+     * This differs from the `accessLevel` Attribute which identifies if the variable has any historical data.
+     *
+     * A value of **true** indicates that the server is actively collecting data.
+     *
+     * A value of **false** indicates the server is not actively collecting data.
+     *
+     * Default value is **false**.
+     */
+    historizing: boolean;
+    /**
+     * returns true if the `accessLevel` flag allows the variable to be readable in the specified context.
+     * @param context
+     */
+    isReadable(context: ISessionContext): boolean;
+    /**
+     * returns true if the `userAccessLevel` flag allows the variable to be readable in the specified context.
+     * @param context
+     */
+    isUserReadable(context: ISessionContext): boolean;
+    /**
+     * returns true if the `accessLevel` flag allows the variable to be writeable in the specified context.
+     * @param context
+     */
+    isWritable(context: ISessionContext): boolean;
+    /**
+     * returns true if the `userAccessLevel` flag allows the variable to be writeable in the specified context.
+     * @param context
+     */
+    isUserWritable(context: ISessionContext): boolean;
+    /***
+     * from OPC.UA.Spec 1.02 part 4
+     *  5.10.2.4 StatusCodes
+     *  Table 51 defines values for the operation level statusCode contained in the DataValue structure of
+     *  each values element. Common StatusCodes are defined in Table 166.
+     *
+     *  **Read Operation Level Result Codes**
+     *
+     *  |Symbolic Id                 | Description|
+     *  |----------------------------|----------------------------------------|
+     *  |BadNodeIdInvalid            | The syntax of the node id is not valid.|
+     *  |BadNodeIdUnknown            | The node id refers to a node that does not exist in the server address space.|
+     *  |BadAttributeIdInvalid       | BadAttributeIdInvalid The attribute is not supported for the specified node.|
+     *  |BadIndexRangeInvalid        | The syntax of the index range parameter is invalid.|
+     *  |BadIndexRangeNoData         | No data exists within the range of indexes specified.|
+     *  |BadDataEncodingInvalid      | The data encoding is invalid. This result is used if no dataEncoding can be applied because an Attribute other than Value was requested or the DataType of the Value Attribute is not a subtype of the Structure DataType. |
+     *  |BadDataEncodingUnsupported  | The server does not support the requested data encoding for the node. This result is used if a dataEncoding can be applied but the passed data encoding is not known to the Server.|
+     *  |BadNotReadable              | The access level does not allow reading or subscribing to the Node.|
+     *  |BadUserAccessDenied         | User does not have permission to perform the requested operation. (table 165)|
+     *  | BadSecurityModeInsufficient | The operation is not permitted over the current secure channel. |
+     *  | BadInsufficientPrivileges   | The user does not have enough privileges to perform the requested operation.
+     */
+    readValue(context?: ISessionContext | null, indexRange?: NumericRange, dataEncoding?: QualifiedNameLike | null): DataValue;
+    readValueAsync(context: ISessionContext | null): Promise<DataValue>;
+    readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>): void;
+    isEnumeration(): boolean;
+    isExtensionObject(): boolean;
+    /**
+     *
+     */
+    readEnumValue(): EnumValue2;
+    /**
+     *
+     * @precondition UAVariable must have a dataType deriving from "Enumeration"
+     */
+    writeEnumValue(value: string | number): void;
+    readAttribute(context: ISessionContext | null, attributeId: AttributeIds, indexRange?: NumericRange, dataEncoding?: QualifiedNameLike | null): DataValue;
+    setValueFromSource(value: VariantLike, statusCode?: StatusCode, sourceTimestamp?: Date): void;
+    writeValue(context: ISessionContext, dataValue: DataValue, indexRange: string | NumericRange | null, callback: StatusCodeCallback): void;
+    writeValue(context: ISessionContext, dataValue: DataValue, callback: StatusCodeCallback): void;
+    writeValue(context: ISessionContext, dataValue: DataValue, indexRange?: string | NumericRange | null): Promise<StatusCode>;
+    asyncRefresh(oldestDate: Date, callback: CallbackT<DataValue>): void;
+    asyncRefresh(oldestDate: Date): Promise<DataValue>;
+    /**
+     * write a variable attribute (callback version)
+     * @param context
+     * @param writeValue
+     * @param callback
+     *
+     * **example**
+     *
+     *  ```javascript
+     *    const writeValue = {
+     *       attributeId: AttributeIds.Value,
+     *       dataValue: new DataValue({
+     *           statusCode: StatusCodes.Good,
+     *           sourceTimestamp: new Date(),
+     *           value: new Variant({ dataType: DataType.Double, value: 3.14 })
+     *       }),
+     *       nodeId
+     *    };
+     *  myVariable.writeAttribute(context,writeValue,(err, statusCode) => {
+     *     if (err) { console.log("Write has failed"); return; }
+     *     console.log("write statusCode = ",statusCode.toString());
+     *  });
+     *  ```
+     *
+     */
+    writeAttribute(context: ISessionContext | null, writeValue: WriteValueOptions, callback: StatusCodeCallback): void;
+    /**
+     * write a variable attribute (async/await version)
+     * @param context
+     * @param writeValue
+     *
+     *
+     * **example**
+     *
+     * ```javascript
+     * try {
+     *    const writeValue = {
+     *       attributeId: AttributeIds.Value,
+     *       dataValue: new DataValue({
+     *           statusCode: StatusCodes.Good,
+     *           sourceTimestamp: new Date(),
+     *           value: new Variant({ dataType: DataType.Double, value: 3.14 })
+     *       }),
+     *       nodeId
+     *    };
+     *    const statusCode = await myVariable.writeAttribute(context,writeValue);
+     * } catch(err) {
+     *   console.log("Write has failed");
+     *   return;
+     * }
+     * console.log("write statusCode = ", statusCode.toString());
+     *  ```
+     *
+     */
+    writeAttribute(context: ISessionContext | null, writeValue: WriteValueOptions): Promise<StatusCode>;
+    touchValue(updateNow?: PreciseClock): void;
+    bindVariable(options?: BindVariableOptions, overwrite?: boolean): void;
+    bindExtensionObject(optionalExtensionObject?: ExtensionObject | ExtensionObject[], options?: BindExtensionObjectOptions): ExtensionObject | ExtensionObject[] | null;
+    bindExtensionObjectScalar(optionalExtensionObject?: ExtensionObject, options?: BindExtensionObjectOptions): ExtensionObject | null;
+    bindExtensionObjectArray(optionalExtensionObjectArray?: ExtensionObject[], options?: BindExtensionObjectOptions): ExtensionObject[] | null;
+    installExtensionObjectVariables(): void;
+    historyRead(context: ISessionContext, historyReadDetails: HistoryReadDetails | ReadRawModifiedDetails | ReadEventDetails | ReadProcessedDetails | ReadAtTimeDetails, indexRange: NumericRange | null, dataEncoding: QualifiedNameLike | null, continuationData: ContinuationData): Promise<HistoryReadResult>;
+    historyRead(context: ISessionContext, historyReadDetails: HistoryReadDetails | ReadRawModifiedDetails | ReadEventDetails | ReadProcessedDetails | ReadAtTimeDetails, indexRange: NumericRange | null, dataEncoding: QualifiedNameLike | null, continuationData: ContinuationData, callback: CallbackT<HistoryReadResult>): void;
+    clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAVariable;
+    on(eventName: "semantic_changed", eventHandler: () => void): this;
+    on(eventName: "value_changed", eventHandler: (dataValue: DataValue) => void): this;
+    once(eventName: "semantic_changed", eventHandler: () => void): this;
+    once(eventName: "value_changed", eventHandler: (dataValue: DataValue) => void): this;
+}

package/dist/ua_variable.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_variable.js.map

package/dist/ua_variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_variable.js","sourceRoot":"","sources":["../source/ua_variable.ts"],"names":[],"mappings":""}

package/dist/ua_variable_t.d.ts

@@ -0,0 +1,15 @@
+import { QualifiedNameLike } from "node-opcua-data-model";
+import { DataValueT } from "node-opcua-data-value";
+import { NumericRange } from "node-opcua-numeric-range";
+import { CallbackT, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+import { ISessionContext } from "./session_context";
+import { UAVariable } from "./ua_variable";
+export interface UAVariableT<T, DT extends DataType> extends UAVariable {
+    readValue(context?: ISessionContext | null, indexRange?: NumericRange, dataEncoding?: QualifiedNameLike | null): DataValueT<T, DT>;
+    readValueAsync(context: ISessionContext | null): Promise<DataValueT<T, DT>>;
+    readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValueT<T, DT>>): void;
+    writeValue(context: ISessionContext, dataValue: DataValueT<T, DT>, indexRange: NumericRange | null, callback: StatusCodeCallback): void;
+    writeValue(context: ISessionContext, dataValue: DataValueT<T, DT>, callback: StatusCodeCallback): void;
+    writeValue(context: ISessionContext, dataValue: DataValueT<T, DT>, indexRange?: NumericRange | null): Promise<StatusCode>;
+}

package/dist/ua_variable_t.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_variable_t.js.map

package/dist/ua_variable_t.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_variable_t.js","sourceRoot":"","sources":["../source/ua_variable_t.ts"],"names":[],"mappings":""}

package/dist/ua_variable_type.d.ts

@@ -0,0 +1,55 @@
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { UInt32 } from "node-opcua-basic-types";
+import { DataType } from "node-opcua-variant";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { BaseNode } from "./base_node";
+import { InstantiateOptions } from "./instantiate_options";
+import { UAObject } from "./ua_object";
+import { UAObjectType } from "./ua_object_type";
+import { UAVariable, VariableAttributes } from "./ua_variable";
+import { UAVariableT } from "./ua_variable_t";
+import { BindVariableOptions } from "./bind_variable";
+import { UAMethod } from "./ua_method";
+export interface InstantiateVariableOptions extends InstantiateOptions {
+    arrayDimensions?: number[] | null;
+    dataType?: string | NodeIdLike;
+    extensionObject?: ExtensionObject | ExtensionObject[];
+    nodeId?: NodeIdLike;
+    minimumSamplingInterval?: number;
+    propertyOf?: NodeIdLike | UAObject | UAObjectType | UAVariable | UAVariableType | UAMethod;
+    value?: BindVariableOptions;
+    /**
+     * This attribute indicates whether the Value attribute of the Variableis an array and how many dimensions the array has.
+     * It may have the following values:
+     *   * n > 1: the Value is an array with the specified number of dimensions.
+     *   * OneDimension (1): The value is an array with one dimension.
+     *   * OneOrMoreDimensions (0): The value is an array with one or more dimensions.
+     *   * Scalar (−1): The value is not an array.
+     *   * Any (−2): The value can be a scalar or an array with any number of dimensions.
+     *   * ScalarOrOneDimension (−3): The value can be a scalar or a one dimensional array.
+     *   * All DataTypes are considered to be scalar, even if they have array-like semantics like ByteString and String.
+     *
+     *
+     * Note: the valueRank of the instantiated variable must be compatible with the valueRank of the VariableType.
+     */
+    valueRank?: number;
+}
+export declare class UAVariableType extends BaseNode implements VariableAttributes {
+    readonly nodeClass: NodeClass.VariableType;
+    readonly subtypeOfObj: UAVariableType | null;
+    readonly subtypeOf: NodeId | null;
+    dataType: NodeId;
+    valueRank: number;
+    minimumSamplingInterval: number;
+    arrayDimensions: UInt32[] | null;
+    historizing: boolean;
+    isAbstract: boolean;
+    isSubtypeOf(type: UAVariableType | NodeIdLike): boolean;
+    /** @deprecated - use isSubtypeOf instead */
+    isSupertypeOf(type: UAVariableType | NodeIdLike): boolean;
+    instantiate(options: InstantiateVariableOptions): UAVariable;
+}
+export interface UAVariableTypeT<T, DT extends DataType> extends UAVariableType {
+    instantiate(options: InstantiateVariableOptions): UAVariableT<T, DT>;
+}

package/dist/ua_variable_type.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_node_1 = require("./base_node");
+//# sourceMappingURL=ua_variable_type.js.map

package/dist/ua_variable_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_variable_type.js","sourceRoot":"","sources":["../source/ua_variable_type.ts"],"names":[],"mappings":";;AAMA,2CAAuC"}

package/dist/ua_view.d.ts

@@ -0,0 +1,7 @@
+import { NodeClass } from "node-opcua-data-model";
+import { BaseNode } from "./base_node";
+import { EventNotifierFlags } from "./event_notifier_flags";
+export interface UAView extends BaseNode {
+    readonly nodeClass: NodeClass.View;
+    readonly eventNotifier: EventNotifierFlags;
+}

package/dist/ua_view.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ua_view.js.map