node-opcua-address-space 2.97.0 → 2.98.0

package/dist/src/address_space.d.ts

@@ -1,387 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-/// <reference types="node" />
-import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
-import { NodeClass } from "node-opcua-data-model";
-import { ExtensionObject } from "node-opcua-extension-object";
-import { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { BrowseResult } from "node-opcua-service-browse";
-import { BrowseDescription, BrowsePath, BrowsePathResult, ModelChangeStructureDataType } from "node-opcua-types";
-import { DataType, VariantT } from "node-opcua-variant";
-import { AddReferenceOpts, IEventData, ISessionContext, UAEventType, UAReference, IHistoricalDataNodeOptions, UAVariable, UADataType, UAObjectType, BaseNode, UAMethod, UAVariableType, UAReferenceType, UAObject, UAView, ShutdownTask, RaiseEventData } from "node-opcua-address-space-base";
-import { UARootFolder } from "../source/ua_root_folder";
-import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
-import { AddressSpacePrivate } from "./address_space_private";
-import { isNonEmptyQualifiedName } from "./namespace_impl";
-import { NamespacePrivate } from "./namespace_private";
-import { ReferenceImpl } from "./reference_impl";
-/**
- * returns true if str matches a nodeID, e.g i=123 or ns=...
- * @method isNodeIdString
- * @param str
- * @type {boolean}
- */
-declare function isNodeIdString(str: unknown): boolean;
-/**
- * `AddressSpace` is a collection of UA nodes.
- *
- *     const addressSpace = AddressSpace.create();
- */
-export declare class AddressSpace implements AddressSpacePrivate {
-    get rootFolder(): UARootFolder;
-    static isNonEmptyQualifiedName: typeof isNonEmptyQualifiedName;
-    static historizerFactory?: any;
-    static create(): AddressSpace;
-    private static registry;
-    /***
-     * @internal
-     * @private
-     */
-    suspendBackReference: boolean;
-    isFrugal: boolean;
-    historizingNodes?: {
-        [key: string]: UAVariable;
-    };
-    _condition_refresh_in_progress: boolean;
-    readonly isNodeIdString: typeof isNodeIdString;
-    private readonly _private_namespaceIndex;
-    private readonly _namespaceArray;
-    private _shutdownTask?;
-    private _modelChangeTransactionCounter;
-    private _modelChanges;
-    constructor();
-    /**
-     * @internal
-     */
-    getDataTypeManager(): ExtraDataTypeManager;
-    getNamespaceUri(namespaceIndex: number): string;
-    /***
-     * @method getNamespace
-     * @param {string|number} namespace index or namespace uri.
-     * @return {NameSpace} the namespace
-     */
-    getNamespace(namespaceIndexOrName: string | number): NamespacePrivate;
-    /***
-     * @method getDefaultNamespace
-     * @return  the  default namespace (standard OPCUA namespace)
-     */
-    getDefaultNamespace(): NamespacePrivate;
-    /***
-     * @method getOwnNamespace
-     *
-     * objects instances managed by the server will be created in this namespace.
-     *
-     * @return  address space own namespace
-     */
-    getOwnNamespace(): NamespacePrivate;
-    /**
-     * @method getNamespaceIndex
-     * @param namespaceUri
-     * @return the namespace index of a namespace given by its namespace uri
-     *
-     */
-    getNamespaceIndex(namespaceUri: string): number;
-    /**
-     * @method registerNamespace
-     *
-     * register a new namespace
-     *
-     * @param namespaceUri {string}
-     * @returns {Namespace}
-     */
-    registerNamespace(namespaceUri: string): NamespacePrivate;
-    /***
-     * @method getNamespaceArray
-     * @return {Namespace[]} the namespace array
-     */
-    getNamespaceArray(): NamespacePrivate[];
-    /**
-     *
-     * @method addAlias
-     * @param alias {String} the alias name
-     * @param nodeId {NodeId}
-     * @internal
-     */
-    addAlias(alias: string, nodeId: NodeId): void;
-    /**
-     * find an node by node Id
-     * @method findNode
-     * @param nodeId   a nodeId or a string coerce-able to nodeID, representing the object to find.
-     * @return {BaseNode|null}
-     */
-    findNode(nodeId: NodeIdLike): BaseNode | null;
-    findMethod(nodeId: NodeId | string): UAMethod | null;
-    /**
-     * resolved a string or a nodeId to a nodeID
-     */
-    resolveNodeId(nodeId: NodeIdLike): NodeId;
-    /**
-     *
-     * @method findObjectType
-     * @param objectType  {String|NodeId|QualifiedName}
-     * @param [namespaceIndex=0 {Number}] an optional namespace index
-     * @return {UAObjectType|null}
-     *
-     * @example
-     *
-     * ```javascript
-     *     const objectType = addressSpace.findObjectType("ns=0;i=58");
-     *     objectType.browseName.toString().should.eql("BaseObjectType");
-     *
-     *     const objectType = addressSpace.findObjectType("BaseObjectType");
-     *     objectType.browseName.toString().should.eql("BaseObjectType");
-     *
-     *     const objectType = addressSpace.findObjectType(resolveNodeId("ns=0;i=58"));
-     *     objectType.browseName.toString().should.eql("BaseObjectType");
-     *
-     *     const objectType = addressSpace.findObjectType("CustomObjectType",36);
-     *     objectType.nodeId.namespace.should.eql(36);
-     *     objectType.browseName.toString().should.eql("BaseObjectType");
-     *
-     *     const objectType = addressSpace.findObjectType("36:CustomObjectType");
-     *     objectType.nodeId.namespace.should.eql(36);
-     *     objectType.browseName.toString().should.eql("BaseObjectType");
-     * ```
-     */
-    findObjectType(objectType: NodeIdLike, namespaceIndex?: number): UAObjectType | null;
-    /**
-     * @method findVariableType
-     * @param variableType  {String|NodeId}
-     * @param [namespaceIndex=0 {Number}] an optional namespace index
-     * @return {UAObjectType|null}
-     *
-     * @example
-     *
-     * ```javascript
-     *     const objectType = addressSpace.findVariableType("ns=0;i=62");
-     *     objectType.browseName.toString().should.eql("BaseVariableType");
-     *
-     *     const objectType = addressSpace.findVariableType("BaseVariableType");
-     *     objectType.browseName.toString().should.eql("BaseVariableType");
-     *
-     *     const objectType = addressSpace.findVariableType(resolveNodeId("ns=0;i=62"));
-     *     objectType.browseName.toString().should.eql("BaseVariableType");
-     * ```
-     */
-    findVariableType(variableType: string | NodeId, namespaceIndex?: number): UAVariableType | null;
-    /**
-     * Find the DataType node from a NodeId or a browseName
-     * @method findDataType
-     * @param dataType {String|NodeId}
-     * @param [namespaceIndex=0 {Number}] an optional namespace index
-     * @return {DataType|null}
-     *
-     *
-     * @example
-     *
-     * ```javascript
-     *      const dataDouble = addressSpace.findDataType("Double");
-     *      const dataDouble = addressSpace.findDataType(resolveNodeId("ns=0;i=3"));
-     * ```
-     */
-    findDataType(dataType: number | string | NodeId | DataType, namespaceIndex?: number): UADataType | null;
-    /**
-     * @method findCorrespondingBasicDataType
-     *
-     * @example
-     *
-     *     const dataType = addressSpace.findDataType("ns=0;i=12");
-     *     addressSpace.findCorrespondingBasicDataType(dataType).should.eql(DataType.String);
-     *
-     *     const dataType = addressSpace.findDataType("ServerStatusDataType"); // ServerStatus
-     *     addressSpace.findCorrespondingBasicDataType(dataType).should.eql(DataType.ExtensionObject);
-     *
-     */
-    findCorrespondingBasicDataType(dataTypeNode: NodeIdLike | UADataType): DataType;
-    /**
-     * find a ReferenceType by its inverse name.
-     * @method findReferenceTypeFromInverseName
-     * @param inverseName  the inverse name of the ReferenceType to find
-     * @deprecated
-     */
-    findReferenceTypeFromInverseName(inverseName: string): UAReferenceType | null;
-    /**
-     * @method findReferenceType
-     * @param refType {String|NodeId}
-     * @param [namespaceIndex=0 {Number}] an optional namespace index
-     * @return {ReferenceType|null}
-     *
-     * refType could be
-     *   - a string representing a nodeid       : e.g.    `i=9004` or ns=1;i=6030
-     *   - a string representing a browse name  : e.g     `"HasTypeDefinition"`.
-     *     In this case it should be in the alias list.
-     *
-     */
-    findReferenceType(refType: NodeIdLike, namespaceIndex?: number): UAReferenceType | null;
-    /**
-     * returns the inverse name of the referenceType.
-     *
-     * @method inverseReferenceType
-     * @param referenceType {String} : the reference type name
-     * @return {String} the name of the inverse reference type.
-     *
-     * @example
-     *
-     *    ```javascript
-     *    addressSpace.inverseReferenceType("OrganizedBy").should.eql("Organizes");
-     *    addressSpace.inverseReferenceType("Organizes").should.eql("OrganizedBy");
-     *    ```
-     *
-     */
-    inverseReferenceType(referenceType: string): string;
-    /**
-     * find an EventType node in the address space
-     * @method findEventType
-     * @param eventTypeId {String|NodeId|UAObjectType} the eventType to find
-     * @param namespaceIndex the namespace index of the event to find
-     * @return {UAObjectType|null} the EventType found or null.
-     *
-     * note:
-     *    - the method with throw an exception if a node is found
-     *      that is not a BaseEventType or a subtype of it.
-     *
-     * @example
-     *
-     *     var evtType = addressSpace.findEventType("AuditEventType");
-     *
-     */
-    findEventType(eventTypeId: NodeIdLike | UAEventType, namespaceIndex?: number): UAEventType | null;
-    /**
-     * EventId is generated by the Server to uniquely identify a particular Event Notification.
-     * @method generateEventId
-     * @return {Variant}  dataType: "ByteString"
-     */
-    generateEventId(): VariantT<Buffer, DataType.ByteString>;
-    constructEventData(eventTypeId: UAEventType, data: RaiseEventData): IEventData;
-    /**
-     * browse some path.
-     *
-     * @method browsePath
-     * @param  {BrowsePath} browsePath
-     * @return {BrowsePathResult}
-     *
-     * This service can be used translates one or more browse paths into NodeIds.
-     * A browse path is constructed of a starting Node and a RelativePath. The specified starting Node
-     * identifies the Node from which the RelativePath is based. The RelativePath contains a sequence of
-     * ReferenceTypes and BrowseNames.
-     *
-     *   |StatusCode                    |                                                            |
-     *   |------------------------------|:-----------------------------------------------------------|
-     *   |BadNodeIdUnknown              |                                                            |
-     *   |BadNodeIdInvalid              |                                                            |
-     *   |BadNothingToDo                | - the relative path contains an empty list )               |
-     *   |BadBrowseNameInvalid          | - target name is missing in relative path                  |
-     *   |UncertainReferenceOutOfServer | - The path element has targets which are in another server.|
-     *   |BadTooManyMatches             |                                                            |
-     *   |BadQueryTooComplex            |                                                            |
-     *   |BadNoMatch                    |                                                            |
-     *
-     *
-     *
-     */
-    browsePath(browsePath: BrowsePath): BrowsePathResult;
-    getExtensionObjectConstructor(dataType: NodeId | UADataType): ExtensionObjectConstructorFuncWithSchema;
-    /**
-     * @param dataType
-     * @param [options]
-     * @return the constructed extension object
-     *
-     *
-     * @example
-     *
-     *             // example 1
-     *             var extObj = addressSpace.constructExtensionObject("BuildInfo",{ productName: "PRODUCT_NAME"});
-     *
-     *             // example 2
-     *             serverStatusDataType.nodeClass.should.eql(NodeClass.DataType);
-     *             serverStatusDataType.browseName.toString().should.eql("ServerStatusDataType");
-     *             var serverStatus  = addressSpace.constructExtensionObject(serverStatusDataType);
-     *             serverStatus.should.be.instanceof(ServerStatusDataType);
-     */
-    constructExtensionObject(dataType: UADataType | NodeId, options?: Record<string, unknown>): ExtensionObject;
-    /**
-     * cleanup all resources maintained by this addressSpace.
-     * @method dispose
-     */
-    dispose(): void;
-    /**
-     * register a function that will be called when the server will perform its shut down.
-     * @method registerShutdownTask
-     */
-    registerShutdownTask(task: ShutdownTask): void;
-    shutdown(): Promise<void>;
-    /**
-     *
-     * @method browseSingleNode
-     * @param nodeId {NodeId|String} : the nodeid of the element to browse
-     * @param browseDescription
-     * @param browseDescription.browseDirection {BrowseDirection} :
-     * @param browseDescription.referenceTypeId {String|NodeId}
-     * @param [session]
-     * @return {BrowseResult}
-     */
-    browseSingleNode(nodeId: NodeIdLike, browseDescription: BrowseDescription, context?: ISessionContext): BrowseResult;
-    /**
-     * @param folder
-     * @private
-     */
-    _coerceFolder(folder: UAObject): BaseNode | null;
-    /**
-     *
-     * @param view
-     * @param modelChange
-     * @private
-     */
-    _collectModelChange(view: UAView | null, modelChange: ModelChangeStructureDataType): void;
-    /**
-     *
-     * walk up the hierarchy of objects until a view is found
-     * objects may belong to multiples views.
-     * Note: this method doesn't return the main view => Server object.
-     * @method extractRootViews
-     * @param node {BaseNode}
-     * @return {BaseNode[]}
-     */
-    /**
-     *
-     * @param node
-     * @private
-     */
-    extractRootViews(node: UAObject | UAVariable): UAView[];
-    /**
-     *
-     * @param func
-     * @private
-     */
-    modelChangeTransaction(func: () => void): void;
-    /**
-     * normalize the ReferenceType field of the Reference Object
-     * @param params.referenceType  {String|nodeId}
-     * @param params.isForward  {Boolean} default value: true;
-     * @return {Object} a new reference object  with the normalized name { referenceType: <value>, isForward: <flag>}
-     */
-    normalizeReferenceType(params: AddReferenceOpts | ReferenceImpl): UAReference;
-    normalizeReferenceTypes(references: AddReferenceOpts[] | ReferenceImpl[] | null): UAReference[];
-    /**
-     *
-     * @param node
-     * @param options
-     */
-    installHistoricalDataNode(node: UAVariable, options?: IHistoricalDataNodeOptions): void;
-    /**
-     *
-     */
-    installAlarmsAndConditionsService(): void;
-    _coerceNode(node: string | BaseNode | NodeId): BaseNode | null;
-    _coerce_DataType(dataType: NodeId | string | BaseNode): NodeId;
-    _coerceTypeDefinition(typeDefinition: string | NodeId): NodeId;
-    _coerceType<T extends BaseNode>(baseType: string | NodeId | BaseNode, topMostBaseType: string, nodeClass: NodeClass): T;
-    _coerce_VariableTypeIds(dataType: NodeId | string | BaseNode): NodeId;
-    _register(node: BaseNode): void;
-    deleteNode(nodeOrNodeId: NodeId | BaseNode): void;
-    isEnumeration(dataType: NodeId): boolean;
-    private _coerce_Type;
-    private _findReferenceType;
-}
-export {};