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

package/dist/instantiate_options.d.ts

@@ -0,0 +1,80 @@
+import { QualifiedNameLike, LocalizedTextLike } from "node-opcua-data-model";
+import { NodeIdLike } from "node-opcua-nodeid";
+import { BaseNode } from "./base_node";
+import { ModellingRuleType } from "./modelling_rule_type";
+import { INamespace } from "./namespace";
+export interface InstantiateOptions {
+    /**
+     * the browse name of the new node to instantiate
+     */
+    browseName: QualifiedNameLike;
+    /**
+     * an optional description
+     *
+     * if not provided the default description of the corresponding Type
+     * will be used.
+     */
+    description?: LocalizedTextLike;
+    /**
+     * an optional displayName
+     *
+     * if not provided the default description of the corresponding browseName
+     * will be used.
+     */
+    displayName?: LocalizedTextLike | null;
+    /**
+     * the parent Folder holding this object
+     *
+     * note
+     *  - when organizedBy is specified, componentOf must not be defined
+     */
+    organizedBy?: NodeIdLike | BaseNode;
+    /**
+     *  the parent Object holding this object
+     * note
+     *  - when componentOf is specified, organizedBy must not be defined
+     */
+    componentOf?: NodeIdLike | BaseNode;
+    /**
+     *
+     */
+    notifierOf?: NodeIdLike | BaseNode;
+    /**
+     *
+     */
+    eventSourceOf?: NodeIdLike | BaseNode;
+    /**
+     * a list of components and properties names that have a HasModellingRule of Optional in the
+     * type definition that we want to instantiate.
+     * Note:
+     *  - the name must follow the OPCUA naming convention and match the browse name of the property (same case)
+     *  - the name can be composed to represent a path to a property or component
+     *
+     * @example
+     *
+     * ```javascript
+     *   optionals: ["MyOptionalVariable", "MyOptionalMethod", "MyOptionalComponent.MyProperty"];
+     * ```
+     *
+     * @default: []
+     */
+    optionals?: string[];
+    /**
+     * modellingRule
+     */
+    modellingRule?: ModellingRuleType;
+    /**
+     * a (optional) predefined nodeId to assigned to the instance
+     * If not specified, a default nodeid will be created.
+     */
+    nodeId?: NodeIdLike;
+    /**
+     * the namespace in which the node shall be instantiated
+     * (if not specified, the default instance namespace (`own namespace`)  of the addressSpace will be used)
+     */
+    namespace?: INamespace;
+    /**
+     * shall we also replicate the HasModelling rule reference ?
+     */
+    copyAlsoModellingRules?: boolean;
+}

package/dist/instantiate_options.js

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

package/dist/instantiate_options.js.map

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

package/dist/modelling_rule_type.d.ts

@@ -0,0 +1 @@
+export type ModellingRuleType = "Mandatory" | "Optional" | "MandatoryPlaceholder" | "OptionalPlaceholder" | "ExposesItsArray" | null;

package/dist/modelling_rule_type.js

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

package/dist/modelling_rule_type.js.map

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

package/dist/namespace.d.ts

@@ -0,0 +1,287 @@
+import { QualifiedNameLike, AccessRestrictionsFlag, LocalizedTextLike } from "node-opcua-data-model";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { ArgumentOptions, AxisInformationOptions, AxisScaleEnumeration, EnumFieldOptions, EUInformationOptions, RangeOptions, RolePermissionType, RolePermissionTypeOptions, StructureFieldOptions } from "node-opcua-types";
+import { VariantLike } from "node-opcua-variant";
+import { UInt32 } from "node-opcua-basic-types";
+import { DataValueOptions } from "node-opcua-data-value";
+import { IAddressSpace } from "./address_space";
+import { AddReferenceOpts, BaseNode, ConstructNodeIdOptions } from "./base_node";
+import { ModellingRuleType } from "./modelling_rule_type";
+import { UADataType } from "./ua_data_type";
+import { UAObject } from "./ua_object";
+import { UAObjectType } from "./ua_object_type";
+import { UAReferenceType } from "./ua_reference_type";
+import { UAVariable } from "./ua_variable";
+import { UAVariableType } from "./ua_variable_type";
+import { BindVariableOptions } from "./bind_variable";
+import { UAView } from "./ua_view";
+import { UAEventType } from "./ua_event_type";
+import { UAMethod } from "./ua_method";
+export interface AddBaseNodeOptions {
+    browseName: QualifiedNameLike;
+    nodeId?: NodeIdLike;
+    displayName?: LocalizedTextLike | LocalizedTextLike[];
+    description?: LocalizedTextLike;
+    componentOf?: NodeIdLike | BaseNode;
+    eventSourceOf?: NodeIdLike | BaseNode;
+    notifierOf?: NodeIdLike | BaseNode;
+    organizedBy?: NodeIdLike | BaseNode;
+    propertyOf?: NodeIdLike | BaseNode;
+    modellingRule?: ModellingRuleType;
+    references?: AddReferenceOpts[];
+    /**
+     *
+     */
+    accessRestrictions?: AccessRestrictionsFlag;
+    /**
+     *
+     */
+    rolePermissions?: RolePermissionTypeOptions[];
+}
+export interface AddObjectTypeOptions extends AddBaseNodeOptions {
+    isAbstract?: boolean;
+    /**
+     * @default BaseObjectType
+     */
+    subtypeOf?: string | UAObjectType;
+    eventNotifier?: number;
+    postInstantiateFunc?: (node: UAObject) => void;
+}
+export interface AddVariableTypeOptions extends AddBaseNodeOptions, VariableStuff {
+    isAbstract?: boolean;
+    /**
+     * @default BaseVariableType
+     */
+    subtypeOf?: string | UAVariableType;
+    postInstantiateFunc?: (node: UAVariableType) => void;
+    value?: VariantLike;
+}
+export interface AddReferenceTypeOptions extends AddBaseNodeOptions {
+    isAbstract?: boolean;
+    inverseName: string;
+    subtypeOf?: string | NodeId | UAReferenceType;
+}
+export interface EnumerationItem {
+    description?: LocalizedTextLike;
+    displayName: LocalizedTextLike;
+    value: number;
+}
+export interface AddEnumerationTypeOptions extends AddBaseNodeOptions {
+    enumeration: string[] | EnumerationItem[];
+}
+export interface AddObjectOptions extends AddBaseNodeOptions {
+    eventNotifier?: number;
+    typeDefinition?: string | NodeId | UAObjectType;
+    nodeVersion?: string;
+    encodingOf?: NodeId | BaseNode;
+}
+export interface AddViewOptions extends AddBaseNodeOptions {
+    typeDefinition?: string | NodeId | UAObjectType;
+}
+export interface AddMethodOptions {
+    nodeId?: NodeIdLike;
+    browseName: QualifiedNameLike;
+    displayName?: LocalizedTextLike;
+    description?: LocalizedTextLike;
+    inputArguments?: ArgumentOptions[];
+    modellingRule?: ModellingRuleType;
+    outputArguments?: ArgumentOptions[];
+    componentOf?: NodeIdLike | BaseNode;
+    executable?: boolean;
+    userExecutable?: boolean;
+    accessRestrictions?: AccessRestrictionsFlag;
+    rolePermissions?: RolePermissionTypeOptions[];
+}
+export type AccessLevelString = string;
+export interface VariableStuff {
+    dataType?: string | NodeIdLike | UADataType;
+    /**
+     * 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?: UInt32;
+    /**
+     * This Attribute specifies the length of each dimension for an array value. T
+     * 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.
+     * For example, if a Variable is defined by the following C array:
+     * Int32 myArray[346];
+     *     then this Variables 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.
+     *     Note that the maximum length of an array transferred on the wire is 2147483647 (max Int32)
+     *     and a multi-dimensional array is encoded as a one dimensional array.
+     */
+    arrayDimensions?: UInt32[] | null;
+    /**
+     * 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.
+     *
+     * https://reference.opcfoundation.org/v104/Core/docs/Part3/8.57/
+     */
+    accessLevel?: UInt32 | AccessLevelString;
+    /**
+     * 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.
+     * https://reference.opcfoundation.org/v104/Core/docs/Part3/8.57/
+     */
+    userAccessLevel?: UInt32 | AccessLevelString;
+    /**
+     * 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;
+    /**
+     * 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;
+    dataValue?: DataValueOptions;
+}
+export interface AddVariableOptionsWithoutValue extends AddBaseNodeOptions, VariableStuff {
+}
+export interface AddVariableOptions extends AddVariableOptionsWithoutValue {
+    typeDefinition?: string | NodeId | UAVariableType;
+    value?: BindVariableOptions;
+    postInstantiateFunc?: (node: UAVariable) => void;
+}
+export interface CreateDataTypeOptions extends AddBaseNodeOptions {
+    isAbstract: boolean;
+    subtypeOf?: string | NodeId | UADataType;
+    partialDefinition?: StructureFieldOptions[] | EnumFieldOptions[];
+}
+/**
+ *
+ * @param options.componentOf {NodeId}
+ * @param options.browseName {String}
+ * @param options.title {String}
+ * @param [options.instrumentRange]
+ * @param [options.instrumentRange.low] {Double}
+ * @param [options.instrumentRange.high] {Double}
+ * @param options.engineeringUnitsRange.low {Double}
+ * @param options.engineeringUnitsRange.high {Double}
+ * @param options.engineeringUnits {String}
+ * @param [options.nodeId = {NodeId}]
+ * @param options.accessLevel
+ * @param options.userAccessLevel
+ * @param options.title {String}
+ * @param options.axisScaleType {AxisScaleEnumeration}
+ *
+ * @param options.xAxisDefinition {AxisInformation}
+ * @param options.xAxisDefinition.engineeringUnits  EURange
+ * @param options.xAxisDefinition.range
+ * @param options.xAxisDefinition.range.low
+ * @param options.xAxisDefinition.range.high
+ * @param options.xAxisDefinition.title  {LocalizedText}
+ * @param options.xAxisDefinition.axisScaleType {AxisScaleEnumeration}
+ * @param options.xAxisDefinition.axisSteps = <null>  {Array<Double>}
+ * @param options.value
+ */
+export interface AddYArrayItemOptions extends AddVariableOptions {
+    title: string;
+    instrumentRange?: RangeOptions;
+    engineeringUnitsRange?: RangeOptions;
+    engineeringUnits?: EUInformationOptions;
+    axisScaleType: AxisScaleEnumeration | string;
+    xAxisDefinition?: AxisInformationOptions;
+}
+export type CreateNodeOptions = any;
+export interface RequiredModel {
+    modelUri: string;
+    version: string;
+    publicationDate: Date;
+}
+export declare interface INamespace {
+    version: string;
+    publicationDate: Date;
+    namespaceUri: string;
+    addressSpace: IAddressSpace;
+    index: number;
+    $emulateVersion103?: boolean;
+    getRequiredModels(): RequiredModel[] | undefined;
+    constructNodeId(options: ConstructNodeIdOptions): NodeId;
+    findObjectType(objectType: string): UAObjectType | null;
+    findVariableType(variableType: string): UAVariableType | null;
+    findDataType(dataType: string): UADataType | null;
+    findReferenceType(referenceType: string): UAReferenceType | null;
+    findReferenceTypeFromInverseName(referenceType: string): UAReferenceType | null;
+    findNode(nodeId: NodeIdLike): BaseNode | null;
+    findNode2(nodeId: NodeId): BaseNode | null;
+    addAlias(aliasName: string, nodeId: NodeId): void;
+    addObjectType(options: AddObjectTypeOptions): UAObjectType;
+    addVariableType(options: AddVariableTypeOptions): UAVariableType;
+    addReferenceType(options: AddReferenceTypeOptions): UAReferenceType;
+    addEnumerationType(options: AddEnumerationTypeOptions): UADataType;
+    createDataType(options: CreateDataTypeOptions): UADataType;
+    addVariable(options: AddVariableOptions): UAVariable;
+    addObject(options: AddObjectOptions): UAObject;
+    addView(options: AddViewOptions): UAView;
+    addFolder(parentFolder: NodeIdLike | UAObject, options: any): UAObject;
+    createNode(options: CreateNodeOptions): BaseNode;
+    /** @private */
+    internalCreateNode(options: CreateNodeOptions): BaseNode;
+    deleteNode(node: NodeId | BaseNode): void;
+    /**
+     * add a new event type to the address space
+     * @example
+     *
+     *      const evtType = namespace.addEventType({
+     *          browseName: "MyAuditEventType",
+     *          subtypeOf:  "AuditEventType"
+     *      });
+     *      const myConditionType = namespace.addEventType({
+     *          browseName: "MyConditionType",
+     *          subtypeOf:  "ConditionType",
+     *          isAbstract: false
+     *      });
+     *
+     */
+    addEventType(options: {
+        browseName: QualifiedNameLike;
+        /**
+         * @default BaseEventType
+         */
+        subtypeOf?: string | UAEventType;
+        isAbstract?: boolean;
+    }): UAEventType;
+    /**
+     *
+     */
+    addMethod(parent: UAObject | UAObjectType, options: AddMethodOptions): UAMethod;
+    toNodeset2XML(): string;
+    /**
+     * @internals
+     */
+    getStandardsNodeIds(): {
+        referenceTypeIds: {
+            [key: string]: string;
+        };
+        objectTypeIds: {
+            [key: string]: string;
+        };
+    };
+    setDefaultRolePermissions(rolePermissions: RolePermissionTypeOptions[] | null): void;
+    getDefaultRolePermissions(): RolePermissionType[] | null;
+    setDefaultAccessRestrictions(accessRestrictions: AccessRestrictionsFlag): void;
+    getDefaultAccessRestrictions(): AccessRestrictionsFlag;
+}

package/dist/namespace.js

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

package/dist/namespace.js.map

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

package/dist/session_context.d.ts

@@ -0,0 +1,56 @@
+import { Certificate } from "node-opcua-crypto";
+import { DataValue } from "node-opcua-data-value";
+import { PreciseClock } from "node-opcua-date-time";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { MessageSecurityMode, PermissionType, ReferenceDescription, UserIdentityToken } from "node-opcua-types";
+import { StatusCode } from "node-opcua-status-code";
+import { ContinuationPoint } from "./continuation_point";
+import { BaseNode } from "./base_node";
+import { UAObject } from "./ua_object";
+import { UAObjectType } from ".";
+export declare function getContextMaxMessageSize(context: ISessionContext): number;
+export interface ITransportSettings {
+    maxMessageSize: number;
+}
+export interface IChannelBase {
+    clientCertificate: Certificate | null;
+    securityMode: MessageSecurityMode;
+    securityPolicy: string;
+    getTransportSettings(): ITransportSettings;
+}
+export interface IContinuationPointInfo<T> {
+    values: T[] | null;
+    continuationPoint: ContinuationPoint | undefined;
+    statusCode: StatusCode;
+}
+export interface ContinuationData {
+    continuationPoint: ContinuationPoint | null;
+    releaseContinuationPoints?: boolean;
+    index?: number;
+}
+export interface IContinuationPointManager {
+    registerHistoryReadRaw(maxElements: number, values: DataValue[], continuationData: ContinuationData): IContinuationPointInfo<DataValue>;
+    getNextHistoryReadRaw(numValues: number, continuationData: ContinuationData): IContinuationPointInfo<DataValue>;
+    registerReferences(maxElements: number, values: ReferenceDescription[], continuationData: ContinuationData): IContinuationPointInfo<ReferenceDescription>;
+    getNextReferences(numValues: number, continuationData: ContinuationData): IContinuationPointInfo<ReferenceDescription>;
+}
+export interface ISessionBase {
+    userIdentityToken?: UserIdentityToken;
+    channel?: IChannelBase;
+    getSessionId(): NodeId;
+    continuationPointManager: IContinuationPointManager;
+}
+export interface ContinuationPointData {
+    dataValues: DataValue[];
+}
+export interface ISessionContext {
+    session?: ISessionBase;
+    getCurrentUserRoles(): NodeId[];
+    checkPermission(node: BaseNode, action: PermissionType): boolean;
+    isBrowseAccessRestricted(node: BaseNode): boolean;
+    currentUserHasRole(role: NodeIdLike): boolean;
+    isAccessRestricted(node: BaseNode): boolean;
+    object?: UAObject | UAObjectType;
+    currentTime?: PreciseClock;
+    userIdentity?: string;
+}

package/dist/session_context.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextMaxMessageSize = void 0;
+function getContextMaxMessageSize(context) {
+    var _a, _b, _c, _d;
+    if (!((_b = (_a = context.session) === null || _a === void 0 ? void 0 : _a.channel) === null || _b === void 0 ? void 0 : _b.getTransportSettings))
+        return 0;
+    const f = (_d = (_c = context.session) === null || _c === void 0 ? void 0 : _c.channel) === null || _d === void 0 ? void 0 : _d.getTransportSettings();
+    return f ? f.maxMessageSize : 0;
+}
+exports.getContextMaxMessageSize = getContextMaxMessageSize;
+//# sourceMappingURL=session_context.js.map

package/dist/session_context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session_context.js","sourceRoot":"","sources":["../source/session_context.ts"],"names":[],"mappings":";;;AAYA,SAAgB,wBAAwB,CAAC,OAAwB;;IAC7D,IAAI,CAAC,CAAA,MAAA,MAAA,OAAO,CAAC,OAAO,0CAAE,OAAO,0CAAE,oBAAoB,CAAA;QAAE,OAAO,CAAC,CAAC;IAC9D,MAAM,CAAC,GAAG,MAAA,MAAA,OAAO,CAAC,OAAO,0CAAE,OAAO,0CAAE,oBAAoB,EAAE,CAAC;IAC3D,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,CAAC;AAJD,4DAIC"}

package/dist/ua_data_type.d.ts

@@ -0,0 +1,34 @@
+import { NodeClass } from "node-opcua-data-model";
+import { ExpandedNodeId, NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { DataType } from "node-opcua-variant";
+import { DataTypeDefinition, EnumDefinition, StructureDefinition } from "node-opcua-types";
+import { BaseNode } from "./base_node";
+export interface UADataType extends BaseNode {
+    readonly nodeClass: NodeClass.DataType;
+    readonly subtypeOfObj: UADataType | null;
+    readonly subtypeOf: NodeId | null;
+    readonly isAbstract: boolean;
+    readonly binaryEncodingDefinition: string | null;
+    readonly binaryEncodingNodeId: ExpandedNodeId | null;
+    readonly binaryEncoding: BaseNode | null;
+    readonly xmlEncodingDefinition: string | null;
+    readonly xmlEncodingNodeId: ExpandedNodeId | null;
+    readonly xmlEncoding: BaseNode | null;
+    readonly jsonEncodingNodeId: ExpandedNodeId | null;
+    readonly jsonEncoding: BaseNode | null;
+    readonly basicDataType: DataType;
+    readonly symbolicName: string;
+    isSubtypeOf(referenceType: NodeIdLike | UADataType): boolean;
+    /** @deprecated - use isSubtypeOf instead */
+    isSupertypeOf(referenceType: NodeIdLike | UADataType): boolean;
+    getEncodingNode(encodingName: string): BaseNode | null;
+    /**
+     *
+     */
+    getDefinition(): DataTypeDefinition;
+    isStructure(): boolean;
+    getStructureDefinition(): StructureDefinition;
+    isEnumeration(): boolean;
+    getEnumDefinition(): EnumDefinition;
+    getBasicDataType(): DataType;
+}

package/dist/ua_data_type.js

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

package/dist/ua_data_type.js.map

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

package/dist/ua_dynamic_variable_array.d.ts

@@ -0,0 +1,14 @@
+import { QualifiedName } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { UADataType } from "./ua_data_type";
+import { UAVariable } from "./ua_variable";
+import { UAVariableType } from "./ua_variable_type";
+export interface UADynamicVariableArray<T extends ExtensionObject = ExtensionObject> extends UAVariable {
+    $dataValue: DataValue;
+    $$variableType: UAVariableType;
+    $$dataType: UADataType;
+    $$extensionObjectArray: T[];
+    $$getElementBrowseName: (obj: T, index: number) => QualifiedName;
+    $$indexPropertyName: string;
+}

package/dist/ua_dynamic_variable_array.js

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

package/dist/ua_dynamic_variable_array.js.map

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

package/dist/ua_event_type.d.ts

@@ -0,0 +1,3 @@
+import { UAObjectType } from "./ua_object_type";
+export interface UAEventType extends UAObjectType {
+}

package/dist/ua_event_type.js

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

package/dist/ua_event_type.js.map

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

package/dist/ua_method.d.ts

@@ -0,0 +1,41 @@
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { Argument, CallMethodResultOptions } from "node-opcua-types";
+import { Variant, VariantLike } from "node-opcua-variant";
+import { CallbackT } from "node-opcua-status-code";
+import { BaseNode } from "./base_node";
+import { ISessionContext } from "./session_context";
+import { UAObject } from "./ua_object";
+import { UAObjectType } from "./ua_object_type";
+import { UAVariable } from "./ua_variable";
+import { CloneExtraInfo, CloneFilter, CloneOptions } from "./clone_options";
+export declare type MethodFunctorC = (this: UAMethod, inputArguments: Variant[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) => void;
+export declare type MethodFunctorA = (this: UAMethod, inputArguments: Variant[], context: ISessionContext) => Promise<CallMethodResultOptions>;
+export type MethodFunctor = MethodFunctorC | MethodFunctorA;
+export declare class UAMethod extends BaseNode {
+    readonly nodeClass: NodeClass.Method;
+    readonly typeDefinition: NodeId;
+    readonly typeDefinitionObj: UAObjectType;
+    readonly parent: UAObject | null;
+    readonly inputArguments?: UAVariable;
+    readonly outputArguments?: UAVariable;
+    readonly methodDeclarationId: NodeId;
+    /**
+     *
+     */
+    _getExecutableFlag?: (sessionContext: ISessionContext | null) => boolean;
+    bindMethod(methodFunction: MethodFunctor): void;
+    getExecutableFlag(context: ISessionContext): boolean;
+    getInputArguments(): Argument[];
+    getOutputArguments(): Argument[];
+    /**
+     * @async
+     * @param inputArguments
+     * @param context
+     * @param callback
+     */
+    execute(object: UAObject | UAObjectType | null, inputArguments: VariantLike[] | null, context: ISessionContext, callback: CallbackT<CallMethodResultOptions>): void;
+    execute(object: UAObject | UAObjectType | null, inputArguments: null | VariantLike[], context: ISessionContext): Promise<CallMethodResultOptions>;
+    clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAMethod;
+    isBound(): boolean;
+}

package/dist/ua_method.js

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

package/dist/ua_method.js.map

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