node-opcua-address-space 2.180.0 → 2.181.0

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.180.0",
+    "version": "2.181.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
-    "main": "./dist/src/index_current.js",
-    "types": "./dist/source/index.d.ts",
+    "main": "./dist/api/index.js",
+    "types": "./dist/api/index.d.ts",
     "engines": {
         "node": ">=18"
     },
@@ -21,49 +21,50 @@
         "@types/semver": "7.8.0",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.180.0",
+        "node-opcua-address-space-base": "2.181.0",
         "node-opcua-assert": "2.179.0",
-        "node-opcua-basic-types": "2.180.0",
-        "node-opcua-binary-stream": "2.180.0",
-        "node-opcua-client-dynamic-extension-object": "2.180.0",
-        "node-opcua-constants": "2.179.0",
-        "node-opcua-crypto": "5.9.0",
-        "node-opcua-data-access": "2.180.0",
-        "node-opcua-data-model": "2.180.0",
-        "node-opcua-data-value": "2.180.0",
-        "node-opcua-date-time": "2.180.0",
-        "node-opcua-debug": "2.179.0",
-        "node-opcua-enum": "2.179.0",
-        "node-opcua-extension-object": "2.180.0",
-        "node-opcua-factory": "2.180.0",
-        "node-opcua-nodeid": "2.179.0",
-        "node-opcua-nodeset-ua": "2.180.0",
-        "node-opcua-numeric-range": "2.180.0",
-        "node-opcua-object-registry": "2.179.0",
-        "node-opcua-pseudo-session": "2.180.0",
-        "node-opcua-service-browse": "2.180.0",
-        "node-opcua-service-call": "2.180.0",
-        "node-opcua-service-history": "2.180.0",
-        "node-opcua-service-translate-browse-path": "2.180.0",
-        "node-opcua-service-write": "2.180.0",
-        "node-opcua-status-code": "2.180.0",
-        "node-opcua-types": "2.180.0",
-        "node-opcua-utils": "2.179.0",
-        "node-opcua-variant": "2.180.0",
-        "node-opcua-xml2json": "2.179.0",
+        "node-opcua-basic-types": "2.181.0",
+        "node-opcua-binary-stream": "2.181.0",
+        "node-opcua-client-dynamic-extension-object": "2.181.0",
+        "node-opcua-constants": "2.181.0",
+        "node-opcua-crypto": "5.10.1",
+        "node-opcua-data-access": "2.181.0",
+        "node-opcua-data-model": "2.181.0",
+        "node-opcua-data-value": "2.181.0",
+        "node-opcua-date-time": "2.181.0",
+        "node-opcua-debug": "2.181.0",
+        "node-opcua-enum": "2.181.0",
+        "node-opcua-extension-object": "2.181.0",
+        "node-opcua-factory": "2.181.0",
+        "node-opcua-nodeid": "2.181.0",
+        "node-opcua-nodeset-ua": "2.181.0",
+        "node-opcua-numeric-range": "2.181.0",
+        "node-opcua-object-registry": "2.181.0",
+        "node-opcua-pseudo-session": "2.181.0",
+        "node-opcua-service-browse": "2.181.0",
+        "node-opcua-service-call": "2.181.0",
+        "node-opcua-service-history": "2.181.0",
+        "node-opcua-service-translate-browse-path": "2.181.0",
+        "node-opcua-service-write": "2.181.0",
+        "node-opcua-status-code": "2.181.0",
+        "node-opcua-types": "2.181.0",
+        "node-opcua-utils": "2.181.0",
+        "node-opcua-variant": "2.181.0",
+        "node-opcua-xml2json": "2.181.0",
         "semver": "^7.8.5",
         "thenify-ex": "4.4.0",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
         "humanize": "0.0.9",
-        "node-opcua-benchmarker": "2.179.0",
-        "node-opcua-leak-detector": "2.179.0",
-        "node-opcua-nodesets": "2.179.0",
-        "node-opcua-packet-analyzer": "2.180.0",
-        "node-opcua-schemas": "2.180.0",
-        "node-opcua-service-filter": "2.180.0",
-        "node-opcua-test-fixtures": "2.179.0"
+        "node-opcua-benchmarker": "2.181.0",
+        "node-opcua-leak-detector": "2.181.0",
+        "node-opcua-nodesets": "2.181.0",
+        "node-opcua-packet-analyzer": "2.181.0",
+        "node-opcua-schemas": "2.181.0",
+        "node-opcua-service-filter": "2.181.0",
+        "node-opcua-test-fixtures": "2.181.0",
+        "node-opcua-test-helpers": "2.181.0"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -80,18 +81,22 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "11ad1e0894355cd279e19443c6c9a4fc090e7d7a",
+    "gitHead": "f8f472c59e681b2aa18ae1533c3d1e5f17614c5c",
     "files": [
         "dist",
         "distHelpers",
         "distNodeJS",
-        "source",
-        "src",
+        "api",
+        "impl",
         "nodeJS.d.ts",
         "nodeJS.js",
         "nodesets",
         "testHelpers.js",
         "testHelpers.d.ts",
-        "source_nodejs"
-    ]
+        "source_nodejs",
+        "bin"
+    ],
+    "bin": {
+        "opcua-nodeset-image": "bin/opcua-nodeset-image.js"
+    }
 }

package/source_nodejs/address_space_digest.ts

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import type { IAddressSpace, UAVariable } from "node-opcua-address-space-base";
+
+export interface AddressSpaceDigest {
+    nodes: number;
+    references: number;
+    hash: string;
+}
+
+/**
+ * a fingerprint of an address space: node count, reference count, and a SHA-1 over every node's
+ * id, browse name, class, reference count and, for variables, status code and value as JSON.
+ * Two address spaces with the same digest hold the same nodes; the tests and the
+ * `opcua-nodeset-image verify` command compare loads with it.
+ */
+export function digestAddressSpace(addressSpace: IAddressSpace): AddressSpaceDigest {
+    const lines: string[] = [];
+    let references = 0;
+    for (const namespace of addressSpace.getNamespaceArray()) {
+        for (const node of namespace.nodeIterator()) {
+            const refs = node.allReferences();
+            references += refs.length;
+            let line = `${node.nodeId.toString()}|${node.browseName.toString()}|${node.nodeClass}|${refs.length}`;
+            if ((node as UAVariable).readValue) {
+                const dataValue = (node as UAVariable).readValue();
+                // JSON, not toString(): the printers colour their output when a terminal is attached and
+                // elide long arrays, so a text digest is neither complete nor the same on every machine
+                line += `|${dataValue.statusCode.toString()}|${JSON.stringify(dataValue.value)}`;
+            }
+            lines.push(line);
+        }
+    }
+    lines.sort();
+    return { nodes: lines.length, references, hash: createHash("sha1").update(lines.join("\n")).digest("hex") };
+}

package/source_nodejs/generate_address_space.ts

@@ -1,28 +1,201 @@
 import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import zlib, { gunzip } from "node:zlib";
 import type { IAddressSpace } from "node-opcua-address-space-base";
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { generateAddressSpaceRaw, type NodeSetLoaderOptions } from "..";
+import {
+    generateAddressSpaceRaw,
+    type NamedNodesetSource,
+    type NodeSetLoaderOptions,
+    type NodesetSource,
+    type NodesetToImageOptions,
+    nodesetImageProblem,
+    nodesetToImage as nodesetToImageRaw,
+    readNodesetImageInfo,
+    setImageInflater,
+    sha256Hex
+} from "../dist/api/index.js";
+import { FileNodesetImageStore } from "./nodeset_image_file_store.js";
 
-const _doDebug = checkDebugFlag(__filename);
-const debugLog = make_debugLog(__filename);
-const errorLog = make_errorLog(__filename);
+// an image given whole inflates through zlib here: a third of the cost of DecompressionStream on
+// a 200 KB image, and in the thread pool, so that the XML hash runs alongside
+const gunzipAsync = promisify(gunzip);
+setImageInflater(async (image) => (await gunzipAsync(image)).toString("utf8"));
 
-export async function readNodeSet2XmlFile(xmlFile: string): Promise<string> {
+const _doDebug = checkDebugFlag("generate_address_space");
+const debugLog = make_debugLog("generate_address_space");
+const errorLog = make_errorLog("generate_address_space");
+
+function checkNodeSet2XmlFileExists(xmlFile: string): void {
     // c8 ignore next
     if (!fs.existsSync(xmlFile)) {
         const msg = `[NODE-OPCUA-E02] generateAddressSpace : cannot find nodeset2 xml file at ${xmlFile}`;
         errorLog(msg);
         throw new Error(msg);
     }
-    debugLog(" parsing ", xmlFile);
+}
+
+export async function readNodeSet2XmlFile(xmlFile: string): Promise<string> {
+    checkNodeSet2XmlFileExists(xmlFile);
+    if (_doDebug) {
+        debugLog(" parsing ", xmlFile);
+    }
     const xmlData = await fs.promises.readFile(xmlFile, "utf-8");
     return xmlData;
 }
 
+/** the chunk size of a nodeset file stream: a few dozen chunks for the standard nodeset */
+const FILE_CHUNK_SIZE = 256 * 1024;
+
+/**
+ * a NodeSet2 file as a source the loader reads in chunks, opened when the loader gets to it
+ */
+export function nodesetSourceFromFile(xmlFile: string): NamedNodesetSource {
+    return {
+        name: xmlFile,
+        source: () => {
+            checkNodeSet2XmlFileExists(xmlFile);
+            if (_doDebug) {
+                debugLog(" parsing ", xmlFile);
+            }
+            return fs.createReadStream(xmlFile, { highWaterMark: FILE_CHUNK_SIZE });
+        }
+    };
+}
+
+/**
+ * a gzip-compressed NodeSet2 file (`<name>.xml.gz`), inflated on the way, opened when the loader
+ * gets to it
+ */
+export function nodesetSourceFromGzipFile(gzipFile: string): NamedNodesetSource {
+    return {
+        name: gzipFile,
+        source: () => {
+            checkNodeSet2XmlFileExists(gzipFile);
+            return fs.createReadStream(gzipFile, { highWaterMark: FILE_CHUNK_SIZE }).pipe(zlib.createGunzip());
+        }
+    };
+}
+
+/**
+ * a NodeSet2 file read whole: what an image store needs, since the digest of the bytes is the
+ * key and a stream can only be hashed once it has been parsed
+ */
+export function nodesetSourceFromFileWhole(xmlFile: string): NamedNodesetSource {
+    checkNodeSet2XmlFileExists(xmlFile);
+    return { name: xmlFile, source: () => [new Uint8Array(fs.readFileSync(xmlFile))] };
+}
+
+/** the image that sits next to a NodeSet2 file: <name>.ndjson.gz */
+export function siblingImageFileOf(xmlFile: string): string {
+    return xmlFile.replace(/\.xml$/i, ".ndjson.gz");
+}
+
+/**
+ * the sibling store: when `<file>.ndjson.gz` sits next to `<file>.xml` and its trailer digest is
+ * the SHA-256 of the XML bytes, the image is what the loader gets; otherwise the XML is. The
+ * digest check is not optional and not cached: an XML edited in place next to a stale image
+ * loads from the XML. Nothing is written here; writing images is the opt-in `imageStore`.
+ * Returns the source to load, and which path was taken for the debug log.
+ */
+async function siblingOrXml(xmlFile: string): Promise<{ source: NamedNodesetSource; path: "image" | "xml"; reason?: string }> {
+    checkNodeSet2XmlFileExists(xmlFile);
+    // the XML is read only when it is going to be parsed or hashed; the image decision starts
+    // with what costs nothing: its size
+    let xmlBytes: Promise<Uint8Array> | undefined;
+    const readXml = () => {
+        xmlBytes = xmlBytes || fs.promises.readFile(xmlFile).then((buffer) => new Uint8Array(buffer));
+        return xmlBytes;
+    };
+    const asXml = async (reason?: string) => {
+        const xml = await readXml();
+        return { source: { name: xmlFile, source: () => [xml] } as NamedNodesetSource, path: "xml" as const, reason };
+    };
+    const imageFile = siblingImageFileOf(xmlFile);
+    let image: Uint8Array;
+    try {
+        image = new Uint8Array(fs.readFileSync(imageFile));
+    } catch {
+        return asXml("no image next to it");
+    }
+    try {
+        // the inflate (zlib, off the main thread) and the hash of the XML (web crypto, off the
+        // main thread too) run alongside; the digest is what decides, the length only rejects early
+        const infoPending = readNodesetImageInfo(image);
+        const digestPending = readXml().then(sha256Hex);
+        digestPending.catch(() => undefined);
+        const info = await infoPending;
+        const sourceLength = info.header.sourceLength;
+        if (sourceLength !== undefined && sourceLength !== fs.statSync(xmlFile).size) {
+            return asXml(`the image is stale: it was built from ${sourceLength} bytes, the XML has ${fs.statSync(xmlFile).size}`);
+        }
+        // a catalog package older or newer than this loader, a stale or truncated image: its XML is still right
+        const problem = nodesetImageProblem(info, await digestPending);
+        if (problem) return asXml(problem);
+    } catch (err) {
+        return asXml(`the image cannot be read: ${(err as Error).message}`);
+    }
+    return { source: { name: `${xmlFile} (image)`, source: image }, path: "image" };
+}
+
+/** the version this package was built as, for the header of the images it writes */
+export function addressSpacePackageVersion(): string {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8")) as { version?: string };
+        return packageJson.version ?? "unknown";
+    } catch {
+        return "unknown";
+    }
+}
+
+/**
+ * load NodeSet2 documents into an address space: file paths, and {@link NodesetSource} values
+ * for a document that is not a file (a gzip stream, an HTTP response, a string of XML). A
+ * string in the list is always a path here; content and streams go through a source.
+ *
+ * A file with a valid precompiled image next to it (`<name>.ndjson.gz`, the catalog ships one
+ * for every nodeset) is replayed from the image, with nothing to configure. With `imageStore`,
+ * a file without one is hashed and its image replayed when the store has it, written
+ * otherwise; `true` selects the per-user file store ({@link FileNodesetImageStore}).
+ * `imageStore: false` disables the sibling images too and streams the XML, for tests and for
+ * bisecting. The documents load in dependency order whatever the order given; a model one of
+ * them requires may also be one the address space holds already, from an earlier call.
+ */
 export async function generateAddressSpace(
     addressSpace: IAddressSpace,
-    xmlFiles: string | string[],
+    xmlFiles: string | Array<string | NodesetSource>,
     options?: NodeSetLoaderOptions
 ): Promise<void> {
-    await generateAddressSpaceRaw(addressSpace, xmlFiles, readNodeSet2XmlFile, options || {});
+    const documents = Array.isArray(xmlFiles) ? xmlFiles : [xmlFiles];
+    const loaderOptions: NodeSetLoaderOptions = { ...(options || {}) };
+    if (loaderOptions.imageStore === false) {
+        // no sibling images, no store: the XML files, streamed
+        const sources = documents.map((document) => (typeof document === "string" ? nodesetSourceFromFile(document) : document));
+        await generateAddressSpaceRaw(addressSpace, sources, { ...loaderOptions, imageStore: undefined });
+        return;
+    }
+    if (loaderOptions.imageStore === true) {
+        loaderOptions.imageStore = new FileNodesetImageStore();
+    }
+    // the sibling store first: a catalog image is replayed with nothing to configure; what has
+    // no valid image next to it goes through the XML, and through the store when there is one
+    const sources: NodesetSource[] = [];
+    for (const document of documents) {
+        if (typeof document !== "string") {
+            sources.push(document);
+            continue;
+        }
+        const { source, path: taken, reason } = await siblingOrXml(document);
+        debugLog(`generateAddressSpace: ${path.basename(document)} from ${taken}${reason ? ` (${reason})` : ""}`);
+        sources.push(source);
+    }
+    await generateAddressSpaceRaw(addressSpace, sources, loaderOptions);
+}
+
+/** the precompiled image of a NodeSet2 file or source, stamped with this package's version */
+export async function nodesetFileToImage(source: NodesetSource | string, options: NodesetToImageOptions = {}): Promise<Uint8Array> {
+    const resolved: NodesetSource =
+        typeof source === "string" && !source.trimStart().startsWith("<") ? nodesetSourceFromFileWhole(source) : source;
+    return nodesetToImageRaw(resolved, { addressSpaceVersion: addressSpacePackageVersion(), ...options });
 }

package/source_nodejs/index.ts

@@ -1 +1,3 @@
-export * from "./generate_address_space";
+export * from "./address_space_digest.js";
+export * from "./generate_address_space.js";
+export * from "./nodeset_image_file_store.js";

package/source_nodejs/nodeset_image_file_store.ts

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { make_debugLog } from "node-opcua-debug";
+import type { NodesetImageStore } from "../dist/api/index.js";
+
+const debugLog = make_debugLog("nodeset_image_file_store");
+
+export interface FileNodesetImageStoreOptions {
+    /**
+     * the directory; defaults to `NODE_OPCUA_NODESET_IMAGE_DIR`, then
+     * `$XDG_CACHE_HOME/node-opcua/nodeset-images`, then `~/.cache/node-opcua/nodeset-images`
+     */
+    directory?: string;
+    /** the size the store stays under, oldest images dropped first @default 256 MiB */
+    maxBytes?: number;
+}
+
+/** the default directory: per user, never the shared temp root, since a server trusts what it reads here */
+export function defaultNodesetImageDirectory(): string {
+    if (process.env.NODE_OPCUA_NODESET_IMAGE_DIR) {
+        return process.env.NODE_OPCUA_NODESET_IMAGE_DIR;
+    }
+    const cache = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+    return path.join(cache, "node-opcua", "nodeset-images");
+}
+
+const IMAGE_EXTENSION = ".ndjson.gz";
+
+/**
+ * the images in a directory of the user's, one file per key, written atomically; a corrupt or
+ * foreign file is the loader's to detect and this store's to replace; the store stays under a
+ * size by dropping the least recently written images
+ */
+export class FileNodesetImageStore implements NodesetImageStore {
+    public readonly directory: string;
+    private readonly maxBytes: number;
+
+    constructor(options: FileNodesetImageStoreOptions = {}) {
+        this.directory = options.directory ?? defaultNodesetImageDirectory();
+        this.maxBytes = options.maxBytes ?? 256 * 1024 * 1024;
+    }
+
+    private fileOf(key: string): string {
+        if (!/^[A-Za-z0-9._-]+$/.test(key)) {
+            throw new Error(`FileNodesetImageStore: not a key: ${key}`);
+        }
+        return path.join(this.directory, key + IMAGE_EXTENSION);
+    }
+
+    public async get(key: string): Promise<Uint8Array | undefined> {
+        const file = this.fileOf(key);
+        let stat: fs.Stats;
+        try {
+            stat = await fs.promises.stat(file);
+        } catch {
+            return undefined;
+        }
+        if (!stat.isFile()) {
+            return undefined;
+        }
+        // on POSIX an image another user could have written is not one to trust
+        if (process.platform !== "win32" && (stat.mode & 0o022) !== 0) {
+            debugLog("ignoring an image writable by others:", file);
+            return undefined;
+        }
+        try {
+            const bytes = await fs.promises.readFile(file);
+            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        } catch (err) {
+            debugLog("cannot read", file, (err as Error).message);
+            return undefined;
+        }
+    }
+
+    public async put(key: string, image: Uint8Array): Promise<void> {
+        const file = this.fileOf(key);
+        await fs.promises.mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const temp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+        await fs.promises.writeFile(temp, image, { mode: 0o600 });
+        await fs.promises.rename(temp, file);
+        await this.evict(file);
+    }
+
+    /** drop the oldest images until the directory fits, never the one just written */
+    private async evict(keep: string): Promise<void> {
+        const names = (await fs.promises.readdir(this.directory)).filter((n) => n.endsWith(IMAGE_EXTENSION));
+        const entries: Array<{ file: string; size: number; mtime: number }> = [];
+        for (const name of names) {
+            const file = path.join(this.directory, name);
+            try {
+                const stat = await fs.promises.stat(file);
+                entries.push({ file, size: stat.size, mtime: stat.mtimeMs });
+            } catch {
+                /* gone meanwhile */
+            }
+        }
+        let total = entries.reduce((n, e) => n + e.size, 0);
+        entries.sort((a, b) => a.mtime - b.mtime);
+        for (const entry of entries) {
+            if (total <= this.maxBytes) {
+                break;
+            }
+            if (entry.file === keep) {
+                continue;
+            }
+            try {
+                await fs.promises.unlink(entry.file);
+                total -= entry.size;
+                debugLog("evicted", entry.file);
+            } catch {
+                /* gone meanwhile */
+            }
+        }
+    }
+
+    /** the keys the directory holds */
+    public async keys(): Promise<string[]> {
+        try {
+            return (await fs.promises.readdir(this.directory))
+                .filter((n) => n.endsWith(IMAGE_EXTENSION))
+                .map((n) => n.slice(0, -IMAGE_EXTENSION.length));
+        } catch {
+            return [];
+        }
+    }
+}

package/dist/source/address_space_ts.d.ts

@@ -1,128 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-import type { AddBaseNodeOptions, AddVariableOptionsWithoutValue, AttributeEventName, BaseNode, BindVariableOptions, IAddressSpace, INamespace, IVariableHistorian, IVariableHistorianOptions, UADynamicVariableArray, UAMethod, UAObject, UAReference, UAReferenceType, UAVariable, UAVariableT, UAVariableType, VariableStuff } from "node-opcua-address-space-base";
-import type { Int64, UAString, UInt32 } from "node-opcua-basic-types";
-import type { AttributeIds, LocalizedText, LocalizedTextLike, QualifiedNameLike } from "node-opcua-data-model";
-import type { DataValue } from "node-opcua-data-value";
-import type { ExtensionObject } from "node-opcua-extension-object";
-import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import type { UAFolder } from "node-opcua-nodeset-ua";
-import type { ReadRawModifiedDetails } from "node-opcua-service-history";
-import type { DataType } from "node-opcua-variant";
-import type { MinimalistAddressSpace } from "../src/reference_impl";
-import type { Namespace } from "./namespace";
-import type { UARootFolder } from "./ua_root_folder";
-export declare function resolveReferenceType(addressSpace: MinimalistAddressSpace, reference: UAReference): UAReferenceType;
-export declare function resolveReferenceNode(addressSpace: MinimalistAddressSpace, reference: UAReference): BaseNode;
-export declare function makeAttributeEventName(attributeId: AttributeIds): AttributeEventName;
-export interface EnumValueTypeOptionsLike {
-    value?: Int64 | UInt32;
-    displayName?: LocalizedTextLike | null;
-    description?: LocalizedTextLike | null;
-}
-export interface AddMultiStateValueDiscreteOptions extends AddVariableOptionsWithoutValue {
-    enumValues: EnumValueTypeOptionsLike[] | {
-        [key: string]: number;
-    };
-    value?: UInt32 | Int64 | BindVariableOptions;
-}
-export declare enum EUEngineeringUnit {
-    degree_celsius = 0
-}
-export interface AddMultiStateDiscreteOptions extends AddBaseNodeOptions, VariableStuff {
-    enumStrings: string[];
-    typeDefinition?: string | NodeId | UAVariableType;
-    postInstantiateFunc?: (node: UAVariable) => void;
-    value?: number | BindVariableOptions;
-}
-export type AddStateVariableOptionals = "EffectiveDisplayName" | "Name" | "Number" | string;
-export interface AddStateVariableOptions extends AddVariableOptionsWithoutValue {
-    id?: NodeIdLike;
-    optionals?: AddStateVariableOptionals[];
-}
-export type AddTwoStateVariableOptionals = AddStateVariableOptionals | "TransitionTime" | "EffectiveTransitionTime" | "TrueState" | "FalseState";
-export interface AddTwoStateVariableOptions extends AddStateVariableOptions {
-    falseState?: LocalizedTextLike;
-    trueState?: LocalizedTextLike;
-    optionals?: AddTwoStateVariableOptionals[];
-    isFalseSubStateOf?: NodeId | string | BaseNode;
-    isTrueSubStateOf?: NodeId | string | BaseNode;
-    value?: boolean | BindVariableOptions;
-}
-export interface AddTwoStateDiscreteOptions extends AddVariableOptionsWithoutValue {
-    falseState?: LocalizedTextLike;
-    trueState?: LocalizedTextLike;
-    optionals?: string[];
-    isFalseSubStateOf?: NodeIdLike | BaseNode;
-    isTrueSubStateOf?: NodeIdLike | BaseNode;
-    value?: boolean | BindVariableOptions;
-    /** @example  "" */
-    definition?: string;
-}
-export interface RangeVariable extends UAVariable {
-    low: UAVariableT<number, DataType.Double>;
-    high: UAVariableT<number, DataType.Double>;
-}
-export interface XAxisDefinitionVariable extends UAVariable {
-    engineeringUnits: UAVariableT<UAString, DataType.String>;
-    title: UAVariableT<LocalizedText, DataType.LocalizedText>;
-    euRange: RangeVariable;
-}
-export declare const NamespaceOptions: {
-    nodeIdNameSeparator: string;
-};
-export interface UATypesFolder extends UAFolder {
-    dataTypes: UAFolder;
-    eventTypes: UAFolder;
-    objectTypes: UAFolder;
-    referenceTypes: UAFolder;
-    variableTypes: UAFolder;
-}
-export interface AddressSpace extends IAddressSpace {
-    getOwnNamespace(): Namespace;
-    registerNamespace(namespaceUri: string): Namespace;
-    rootFolder: UARootFolder;
-}
-export interface IHistorizerFactory {
-    create(node: UAVariable, options: IVariableHistorianOptions): IVariableHistorian;
-}
-export declare class AddressSpace {
-    static historizerFactory?: IHistorizerFactory;
-    static create(): AddressSpace;
-    private constructor();
-}
-export declare class VariableHistorian implements IVariableHistorian {
-    constructor(node: UAVariable, options: IVariableHistorianOptions);
-    /**
-     * 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 type UAClonable = UAObject | UAVariable | UAMethod;
-export interface CreateExtObjArrayNodeOptions {
-    browseName: QualifiedNameLike;
-    complexVariableType: string | NodeId;
-    variableType: string | NodeId;
-    indexPropertyName: string;
-    minimumSamplingInterval?: number;
-}
-export declare function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: CreateExtObjArrayNodeOptions): UADynamicVariableArray<T>;
-export declare function bindExtObjArrayNode<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, variableTypeNodeId: string | NodeId, indexPropertyName: string): UAVariable;
-export declare function addElement<T extends ExtensionObject>(options: Record<string, unknown> | ExtensionObject | UAVariable, uaArrayVariableNode: UADynamicVariableArray<T>): UAVariable;
-export declare function removeElement<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, element: number | UAVariable | ((a: T) => boolean)): void;
-export declare function dumpXml(node: BaseNode, options: Record<string, unknown>): string;
-export declare function dumpToBSD(namespace: INamespace): string;
-export declare function adjustNamespaceArray(addressSpace: IAddressSpace): void;

package/dist/source/address_space_ts.js

@@ -1,23 +0,0 @@
-"use strict";
-/**
- * @module node-opcua-address-space
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddressSpace = exports.EUEngineeringUnit = void 0;
-var EUEngineeringUnit;
-(function (EUEngineeringUnit) {
-    EUEngineeringUnit[EUEngineeringUnit["degree_celsius"] = 0] = "degree_celsius";
-    // to be continued
-})(EUEngineeringUnit || (exports.EUEngineeringUnit = EUEngineeringUnit = {}));
-// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: interface adds typed members/overloads for this class
-class AddressSpace {
-    static historizerFactory;
-    static create() {
-        return new AddressSpace();
-    }
-    constructor() {
-        /* empty */
-    }
-}
-exports.AddressSpace = AddressSpace;
-//# sourceMappingURL=address_space_ts.js.map

package/dist/source/address_space_ts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"address_space_ts.js","sourceRoot":"","sources":["../../source/address_space_ts.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAoDH,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IACzB,6EAAc,CAAA;IACd,kBAAkB;AACtB,CAAC,EAHW,iBAAiB,iCAAjB,iBAAiB,QAG5B;AAsFD,iHAAiH;AACjH,MAAa,YAAY;IACd,MAAM,CAAC,iBAAiB,CAAsB;IAE9C,MAAM,CAAC,MAAM;QAChB,OAAO,IAAI,YAAY,EAAkB,CAAC;IAC9C,CAAC;IAED;QACI,WAAW;IACf,CAAC;CACJ;AAVD,oCAUC"}