node-opcua-alias-name-client 2.176.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-2024  Sterfive SAS - 833264583 RCS ORLEANS - France (https://www.sterfive.com)
+
+Copyright (c) 2014-2022 Etienne Rossignon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# node-opcua-alias-name-client
+
+Client-side OPC UA **AliasNames** (OPC 10000-17).
+
+These packages let a Server publish **its own** AliasNames and let a Client resolve
+them. They do **not** aggregate AliasNames collected from other Servers: Annex B
+(aggregating Server) and Annex C (GDS) of OPC 10000-17, and the Annex D PubSub change
+notification, are out of scope. Anything that requires knowing about more than one
+Server is not implemented here.
+
+see http://node-opcua.github.io/
+
+## What it is for
+
+Part 17 is, in effect, DNS for an address space. Instead of configuring a Client with a
+raw NodeId that changes whenever the Server is re-engineered, ask for the plant tag:
+
+```ts
+import { ClientAliasSet } from "node-opcua-alias-name-client";
+
+const aliases = new ClientAliasSet(session);
+const [entry] = await aliases.findAlias("TI101");
+const nodeId = entry.referencedNodes[0];
+```
+
+## Installation
+
+```bash
+npm install node-opcua-alias-name-client
+```
+
+## Works with any session
+
+`ClientAliasSet` takes an `IBasicSessionAsync2`, so the same code drives a remote
+`ClientSession` and an in-process `PseudoSession`:
+
+```ts
+const aliases = new ClientAliasSet(new PseudoSession(addressSpace));
+```
+
+That is what lets this package be tested without a transport, and what lets a
+Server-side tool resolve its own aliases through the API a Client uses.
+
+## Searching
+
+The argument is an OPC 10000-4 `Like` pattern — `%` is any run of characters, `_` exactly
+one, `[abc]` and `[^abc]` are lists, `\` escapes. An exact name is a pattern with no
+wildcards.
+
+```ts
+await aliases.findAlias("TI101");                              // exact
+await aliases.findAlias("TI%");                                // prefix
+await aliases.findAlias("%", { categoryNodeId: TAG_VARIABLES }); // one branch
+```
+
+The search is recursive from the category given, defaulting to the `Aliases` root, so one
+call covers everything the Server publishes.
+
+Results are **typed**, never raw Variants: `aliasName` is a string, `referencedNodes` is
+`ExpandedNodeId[]`, ordered best match first (clause 6.3.2).
+
+No match is an empty array, not an error — clause 6.3.2 Table 3 makes that a `Good`
+response. A Server-side failure raises `AliasNameCallError`, which carries the StatusCode
+so the cases of Table 4 stay distinguishable:
+
+```ts
+try {
+    await aliases.findAlias(userSuppliedPattern);
+} catch (err) {
+    if (err instanceof AliasNameCallError && err.statusCode.equals(StatusCodes.BadResponseTooLarge)) {
+        // ask the user to narrow the pattern
+    }
+}
+```
+
+## `FindAliasVerbose` is optional — handle its absence
+
+Only `FindAlias` is MANDATORY (clause 6.3). A Server exposing nothing else is perfectly
+conformant, so its absence is an outcome to handle rather than a fault:
+
+```ts
+if (await aliases.supportsVerbose()) {
+    const entries = await aliases.findAliasVerbose("TI101");
+    entries[0].aliasNameCategoryId;  // which category held it
+    entries[0].serverUris;           // parallel to referencedNodes; null = this Server
+}
+```
+
+Calling it anyway raises `AliasNameMethodNotSupportedError`, naming the Method and the
+category, **before any call is made** — the absence is discovered while resolving NodeIds,
+so it never arrives as an unhandled `Bad_NotImplemented` from the wire.
+
+`supportsConfiguration()` does the same for `AddAliasesToCategory` /
+`DeleteAliasesFromCategory`.
+
+## Method NodeIds are resolved once
+
+All four Methods of a category are resolved in a **single** `translateBrowsePath` round
+trip and cached for the life of the instance — asking for four costs no more than asking
+for one, so a later `findAliasVerbose` after a `findAlias` makes no further round trip.
+Construct one `ClientAliasSet` per session; call `invalidate()` if the Server's address
+space changes underneath it.
+
+## Nodes on another Server (Annex A)
+
+A returned `ExpandedNodeId` may carry a non-zero `ServerIndex`, which says only "this Node
+is somewhere else" — the index means nothing without the Server's `ServerArray`. That
+lookup is the step every Client has to perform, so it is here rather than in each caller:
+
+```ts
+const located = await aliases.serverIndexResolver.locate(entry.referencedNodes[0]);
+if (!located.local) {
+    connectTo(located.serverUri);
+}
+```
+
+The `ServerArray` is read once and cached. Every Node these packages publish is local, so
+`local` is always true against a Server built with `node-opcua-alias-name-server`; this
+matters when talking to a Server that does aggregate.
+
+## Browsing the hierarchy
+
+Resolving an alias needs no browsing — `findAlias` on the root searches recursively — but
+a Client that wants to show the tree, or search one branch, can walk it:
+
+```ts
+for (const category of await aliases.browseSubCategories()) {
+    console.log(category.browseName, category.nodeId.toString());
+}
+```
+
+Only `AliasNameCategoryType` instances are returned; the `AliasNameType` instances a
+category also Organizes are not categories and are filtered out.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/client_alias_set.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @module node-opcua-alias-name-client
+ *
+ * Client-side API for OPC UA AliasNames (OPC 10000-17).
+ *
+ * All navigation goes through {@link IBasicSessionAsync2} — browse, read, call,
+ * translateBrowsePath — so the same code drives a remote `ClientSession` and an
+ * in-process `PseudoSession`. That is what lets these be tested without a
+ * transport, and what lets a Server-side tool resolve its own aliases through
+ * the same API a Client uses.
+ */
+import { type ExpandedNodeId, type NodeId } from "node-opcua-nodeid";
+import type { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import { ServerIndexResolver } from "./server_index_resolver.js";
+/** `Aliases`, the root of the hierarchy (OPC 10000-17 clause 9.2). */
+export declare const ALIASES_ROOT: NodeId;
+/** `TagVariables` (clause 9.3). */
+export declare const TAG_VARIABLES: NodeId;
+/** `Topics` (clause 9.4). */
+export declare const TOPICS: NodeId;
+/** One resolved AliasName, as `FindAlias` reports it (clause 7.2). */
+export interface ClientAliasEntry {
+    /** The string part of the AliasName. */
+    aliasName: string;
+    /**
+     * The namespace the AliasName was published in.
+     *
+     * Clause 6.2 requires a Client to **ignore this when comparing** AliasNames.
+     * It is reported for completeness, not for matching.
+     */
+    namespaceIndex: number;
+    /** The Nodes the alias names, best match first (clause 6.3.2). */
+    referencedNodes: ExpandedNodeId[];
+}
+/** One resolved AliasName, as `FindAliasVerbose` reports it (clause 7.3). */
+export interface ClientAliasVerboseEntry extends ClientAliasEntry {
+    /**
+     * Parallel to {@link referencedNodes}: the ServerUri of each Node, `null`
+     * for one on the Server that answered.
+     */
+    serverUris: (string | null)[];
+    /**
+     * The category that actually held the alias, which for a recursive search is
+     * the nested one rather than the one that was called.
+     */
+    aliasNameCategoryId: NodeId;
+}
+export interface FindAliasOptions {
+    /**
+     * The category to search, recursively. Defaults to {@link ALIASES_ROOT},
+     * which covers everything the Server publishes.
+     */
+    categoryNodeId?: NodeId;
+    /**
+     * Restrict to this ReferenceType and its subtypes (clause 6.3.2 Table 3).
+     * Omit for any.
+     */
+    referenceTypeFilter?: NodeId;
+}
+/**
+ * Client-side entry point for a Server's AliasNames.
+ *
+ * ```ts
+ * const aliases = new ClientAliasSet(session);
+ * const [entry] = await aliases.findAlias("TI101");
+ * const nodeId = entry.referencedNodes[0];
+ * ```
+ *
+ * Construct one per session: Method NodeIds are resolved lazily, in a single
+ * `translateBrowsePath` round trip per category, and cached for the lifetime of
+ * the instance.
+ *
+ * This resolves the aliases **a Server publishes about itself**. Aggregating
+ * across Servers (OPC 10000-17 Annexes B and C) is out of scope; where a Server
+ * does aggregate, {@link serverIndexResolver} turns the `ServerIndex` of a
+ * returned `ExpandedNodeId` into a URI.
+ */
+export declare class ClientAliasSet {
+    readonly session: IBasicSessionAsync2;
+    /** Resolves the `ServerIndex` of a returned Node (Annex A). */
+    readonly serverIndexResolver: ServerIndexResolver;
+    private readonly methodCache;
+    constructor(session: IBasicSessionAsync2);
+    /**
+     * Resolve an AliasName, or a `Like` pattern, to the Nodes it names.
+     *
+     * The pattern is an OPC 10000-4 `Like` pattern: `%` is any run of
+     * characters, `_` is exactly one, `[abc]` and `[^abc]` are lists, and `\`
+     * escapes. An exact name is simply a pattern with no wildcards.
+     *
+     * @throws {@link AliasNameCallError} when the Server answers a bad
+     * StatusCode — `Bad_InvalidArgument` for a malformed pattern,
+     * `Bad_ResponseTooLarge` when a narrower filter is needed,
+     * `Bad_UserAccessDenied` when the session may not read the category.
+     */
+    findAlias(pattern: string, options?: FindAliasOptions): Promise<ClientAliasEntry[]>;
+    /**
+     * Resolve an AliasName and learn which category held it and which Server
+     * each Node is on (clause 6.3.3).
+     *
+     * @throws {@link AliasNameMethodNotSupportedError} when the Server exposes
+     * only the mandatory `FindAlias`. That is a conformant Server, so this is
+     * an expected outcome to handle, not a fault — use {@link supportsVerbose}
+     * to check first.
+     */
+    findAliasVerbose(pattern: string, options?: FindAliasOptions): Promise<ClientAliasVerboseEntry[]>;
+    /**
+     * True when the Server exposes `FindAliasVerbose` on this category.
+     *
+     * Cheaper than catching {@link AliasNameMethodNotSupportedError}, and reads
+     * better when the Client has a fallback path.
+     */
+    supportsVerbose(categoryNodeId?: NodeId): Promise<boolean>;
+    /**
+     * True when the Server exposes the configuration Methods on this category
+     * (clauses 6.3.4 and 6.3.5). They are optional and off by default in most
+     * Servers.
+     */
+    supportsConfiguration(categoryNodeId?: NodeId): Promise<boolean>;
+    /**
+     * The `AliasNameCategoryType` instances Organized directly by a category.
+     *
+     * Browsing is not needed to *resolve* an alias — `FindAlias` on the root
+     * searches recursively — but a Client that wants to show the hierarchy, or
+     * to search one branch, needs it.
+     */
+    browseSubCategories(categoryNodeId?: NodeId): Promise<Array<{
+        nodeId: NodeId;
+        browseName: string;
+    }>>;
+    /** Forget every cached Method NodeId. */
+    invalidate(): void;
+    /**
+     * Resolve every Method of a category in **one** `translateBrowsePath` round
+     * trip, and cache the result.
+     *
+     * Asking for all four at once costs no more than asking for one, and means a
+     * Client that later calls `findAliasVerbose` after `findAlias` makes no
+     * further round trip.
+     */
+    private resolveMethods;
+    /** Call one of the two find Methods and return its ExtensionObject array. */
+    private callFind;
+}

package/dist/client_alias_set.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * @module node-opcua-alias-name-client
+ *
+ * Client-side API for OPC UA AliasNames (OPC 10000-17).
+ *
+ * All navigation goes through {@link IBasicSessionAsync2} — browse, read, call,
+ * translateBrowsePath — so the same code drives a remote `ClientSession` and an
+ * in-process `PseudoSession`. That is what lets these be tested without a
+ * transport, and what lets a Server-side tool resolve its own aliases through
+ * the same API a Client uses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAliasSet = exports.TOPICS = exports.TAG_VARIABLES = exports.ALIASES_ROOT = void 0;
+const node_opcua_constants_1 = require("node-opcua-constants");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+const node_opcua_service_translate_browse_path_1 = require("node-opcua-service-translate-browse-path");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const errors_js_1 = require("./errors.js");
+const server_index_resolver_js_1 = require("./server_index_resolver.js");
+/** `Aliases`, the root of the hierarchy (OPC 10000-17 clause 9.2). */
+exports.ALIASES_ROOT = (0, node_opcua_nodeid_1.resolveNodeId)(node_opcua_constants_1.ObjectIds.Aliases);
+/** `TagVariables` (clause 9.3). */
+exports.TAG_VARIABLES = (0, node_opcua_nodeid_1.resolveNodeId)(node_opcua_constants_1.ObjectIds.TagVariables);
+/** `Topics` (clause 9.4). */
+exports.TOPICS = (0, node_opcua_nodeid_1.resolveNodeId)(node_opcua_constants_1.ObjectIds.Topics);
+/** Read a QualifiedName's parts defensively — a Server may send a bare string. */
+function qualifiedName(value) {
+    return { name: value?.name ?? "", namespaceIndex: value?.namespaceIndex ?? 0 };
+}
+/**
+ * Client-side entry point for a Server's AliasNames.
+ *
+ * ```ts
+ * const aliases = new ClientAliasSet(session);
+ * const [entry] = await aliases.findAlias("TI101");
+ * const nodeId = entry.referencedNodes[0];
+ * ```
+ *
+ * Construct one per session: Method NodeIds are resolved lazily, in a single
+ * `translateBrowsePath` round trip per category, and cached for the lifetime of
+ * the instance.
+ *
+ * This resolves the aliases **a Server publishes about itself**. Aggregating
+ * across Servers (OPC 10000-17 Annexes B and C) is out of scope; where a Server
+ * does aggregate, {@link serverIndexResolver} turns the `ServerIndex` of a
+ * returned `ExpandedNodeId` into a URI.
+ */
+class ClientAliasSet {
+    session;
+    /** Resolves the `ServerIndex` of a returned Node (Annex A). */
+    serverIndexResolver;
+    methodCache = new Map();
+    constructor(session) {
+        this.session = session;
+        this.serverIndexResolver = new server_index_resolver_js_1.ServerIndexResolver(session);
+    }
+    /**
+     * Resolve an AliasName, or a `Like` pattern, to the Nodes it names.
+     *
+     * The pattern is an OPC 10000-4 `Like` pattern: `%` is any run of
+     * characters, `_` is exactly one, `[abc]` and `[^abc]` are lists, and `\`
+     * escapes. An exact name is simply a pattern with no wildcards.
+     *
+     * @throws {@link AliasNameCallError} when the Server answers a bad
+     * StatusCode — `Bad_InvalidArgument` for a malformed pattern,
+     * `Bad_ResponseTooLarge` when a narrower filter is needed,
+     * `Bad_UserAccessDenied` when the session may not read the category.
+     */
+    async findAlias(pattern, options) {
+        const categoryNodeId = options?.categoryNodeId ?? exports.ALIASES_ROOT;
+        const methods = await this.resolveMethods(categoryNodeId);
+        if (!methods.findAlias) {
+            // FindAlias is MANDATORY, so this means the Node is not an
+            // AliasNameCategoryType instance, or the Server is non-conformant
+            throw new errors_js_1.AliasNameMethodNotSupportedError("FindAlias", categoryNodeId);
+        }
+        const extensionObjects = await this.callFind("FindAlias", categoryNodeId, methods.findAlias, pattern, options?.referenceTypeFilter);
+        return extensionObjects.map((raw) => {
+            const value = raw;
+            const { name, namespaceIndex } = qualifiedName(value.aliasName);
+            return {
+                aliasName: name,
+                namespaceIndex,
+                referencedNodes: value.referencedNodes ?? []
+            };
+        });
+    }
+    /**
+     * Resolve an AliasName and learn which category held it and which Server
+     * each Node is on (clause 6.3.3).
+     *
+     * @throws {@link AliasNameMethodNotSupportedError} when the Server exposes
+     * only the mandatory `FindAlias`. That is a conformant Server, so this is
+     * an expected outcome to handle, not a fault — use {@link supportsVerbose}
+     * to check first.
+     */
+    async findAliasVerbose(pattern, options) {
+        const categoryNodeId = options?.categoryNodeId ?? exports.ALIASES_ROOT;
+        const methods = await this.resolveMethods(categoryNodeId);
+        if (!methods.findAliasVerbose) {
+            throw new errors_js_1.AliasNameMethodNotSupportedError("FindAliasVerbose", categoryNodeId);
+        }
+        const extensionObjects = await this.callFind("FindAliasVerbose", categoryNodeId, methods.findAliasVerbose, pattern, options?.referenceTypeFilter);
+        return extensionObjects.map((raw) => {
+            const value = raw;
+            const { name, namespaceIndex } = qualifiedName(value.aliasName);
+            return {
+                aliasName: name,
+                namespaceIndex,
+                referencedNodes: value.referencedNodes ?? [],
+                serverUris: value.serverUris ?? [],
+                aliasNameCategoryId: value.aliasNameCategoryId
+            };
+        });
+    }
+    /**
+     * True when the Server exposes `FindAliasVerbose` on this category.
+     *
+     * Cheaper than catching {@link AliasNameMethodNotSupportedError}, and reads
+     * better when the Client has a fallback path.
+     */
+    async supportsVerbose(categoryNodeId = exports.ALIASES_ROOT) {
+        return (await this.resolveMethods(categoryNodeId)).findAliasVerbose !== null;
+    }
+    /**
+     * True when the Server exposes the configuration Methods on this category
+     * (clauses 6.3.4 and 6.3.5). They are optional and off by default in most
+     * Servers.
+     */
+    async supportsConfiguration(categoryNodeId = exports.ALIASES_ROOT) {
+        const methods = await this.resolveMethods(categoryNodeId);
+        return methods.addAliasesToCategory !== null && methods.deleteAliasesFromCategory !== null;
+    }
+    /**
+     * The `AliasNameCategoryType` instances Organized directly by a category.
+     *
+     * Browsing is not needed to *resolve* an alias — `FindAlias` on the root
+     * searches recursively — but a Client that wants to show the hierarchy, or
+     * to search one branch, needs it.
+     */
+    async browseSubCategories(categoryNodeId = exports.ALIASES_ROOT) {
+        const result = await this.session.browse({
+            nodeId: categoryNodeId,
+            browseDirection: node_opcua_data_model_1.BrowseDirection.Forward,
+            referenceTypeId: (0, node_opcua_nodeid_1.resolveNodeId)("Organizes"),
+            includeSubtypes: true,
+            nodeClassMask: node_opcua_data_model_1.NodeClass.Object,
+            resultMask: 0x3f
+        });
+        const references = result.references ?? [];
+        const out = [];
+        for (const reference of references) {
+            // an AliasNameCategoryType instance carries FindAlias; an
+            // AliasNameType instance does not, which is how they are told apart
+            // without reading TypeDefinition for each
+            const methods = await this.resolveMethods(reference.nodeId);
+            if (methods.findAlias) {
+                out.push({ nodeId: reference.nodeId, browseName: reference.browseName.name ?? "" });
+            }
+        }
+        return out;
+    }
+    /** Forget every cached Method NodeId. */
+    invalidate() {
+        this.methodCache.clear();
+        this.serverIndexResolver.invalidate();
+    }
+    /**
+     * Resolve every Method of a category in **one** `translateBrowsePath` round
+     * trip, and cache the result.
+     *
+     * Asking for all four at once costs no more than asking for one, and means a
+     * Client that later calls `findAliasVerbose` after `findAlias` makes no
+     * further round trip.
+     */
+    async resolveMethods(categoryNodeId) {
+        const key = categoryNodeId.toString();
+        const cached = this.methodCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const names = ["FindAlias", "FindAliasVerbose", "AddAliasesToCategory", "DeleteAliasesFromCategory"];
+        const results = await this.session.translateBrowsePath(names.map((name) => (0, node_opcua_service_translate_browse_path_1.makeBrowsePath)(categoryNodeId, `/${name}`)));
+        const pick = (index) => {
+            const result = results[index];
+            return result?.statusCode.isGood() && result.targets?.length ? result.targets[0].targetId : null;
+        };
+        const methods = {
+            findAlias: pick(0),
+            findAliasVerbose: pick(1),
+            addAliasesToCategory: pick(2),
+            deleteAliasesFromCategory: pick(3)
+        };
+        this.methodCache.set(key, methods);
+        return methods;
+    }
+    /** Call one of the two find Methods and return its ExtensionObject array. */
+    async callFind(methodName, categoryNodeId, methodId, pattern, referenceTypeFilter) {
+        const result = await this.session.call({
+            objectId: categoryNodeId,
+            methodId,
+            inputArguments: [
+                { dataType: node_opcua_variant_1.DataType.String, value: pattern },
+                // an omitted filter is the null NodeId, not a null value
+                { dataType: node_opcua_variant_1.DataType.NodeId, value: referenceTypeFilter ?? node_opcua_nodeid_1.NodeId.nullNodeId }
+            ]
+        });
+        if (!result.statusCode.isGood()) {
+            throw new errors_js_1.AliasNameCallError(methodName, categoryNodeId, result.statusCode);
+        }
+        const output = result.outputArguments?.[0];
+        const value = output?.value;
+        // no match is Good with an empty list (clause 6.3.2 Table 3)
+        if (value === null || value === undefined) {
+            return [];
+        }
+        return Array.isArray(value) ? value : [value];
+    }
+}
+exports.ClientAliasSet = ClientAliasSet;
+//# sourceMappingURL=client_alias_set.js.map

package/dist/client_alias_set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client_alias_set.js","sourceRoot":"","sources":["../source/client_alias_set.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module node-opcua-alias-name-client
+ */
+import type { NodeId } from "node-opcua-nodeid";
+import type { StatusCode } from "node-opcua-status-code";
+/**
+ * The Server does not expose the Method that was asked for.
+ *
+ * `FindAlias` is MANDATORY on every `AliasNameCategoryType` instance, but
+ * `FindAliasVerbose`, `AddAliasesToCategory` and `DeleteAliasesFromCategory` are
+ * all optional (OPC 10000-17 clause 6.3). A Server that implements only the
+ * mandatory Method is perfectly conformant, so a Client that wants the verbose
+ * form must be able to tell "this Server does not offer it" apart from "the call
+ * failed".
+ *
+ * Raised before any call is made — the Method's absence is discovered while
+ * resolving NodeIds — so it never surfaces as an unhandled `Bad_NotImplemented`
+ * from the wire.
+ */
+export declare class AliasNameMethodNotSupportedError extends Error {
+    /** The Method that is missing, by BrowseName. */
+    readonly methodName: string;
+    /** The category it was looked for on. */
+    readonly categoryNodeId: NodeId;
+    constructor(methodName: string, categoryNodeId: NodeId);
+}
+/**
+ * The Server answered a `FindAlias` call with a bad StatusCode.
+ *
+ * Carries the code so a caller can distinguish the cases clause 6.3.2 Table 4
+ * defines — `Bad_InvalidArgument` for a malformed search pattern,
+ * `Bad_ResponseTooLarge` for a result set that needs a narrower filter,
+ * `Bad_UserAccessDenied` for a category the session may not read.
+ */
+export declare class AliasNameCallError extends Error {
+    readonly statusCode: StatusCode;
+    readonly categoryNodeId: NodeId;
+    constructor(methodName: string, categoryNodeId: NodeId, statusCode: StatusCode);
+}

package/dist/errors.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * @module node-opcua-alias-name-client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasNameCallError = exports.AliasNameMethodNotSupportedError = void 0;
+/**
+ * The Server does not expose the Method that was asked for.
+ *
+ * `FindAlias` is MANDATORY on every `AliasNameCategoryType` instance, but
+ * `FindAliasVerbose`, `AddAliasesToCategory` and `DeleteAliasesFromCategory` are
+ * all optional (OPC 10000-17 clause 6.3). A Server that implements only the
+ * mandatory Method is perfectly conformant, so a Client that wants the verbose
+ * form must be able to tell "this Server does not offer it" apart from "the call
+ * failed".
+ *
+ * Raised before any call is made — the Method's absence is discovered while
+ * resolving NodeIds — so it never surfaces as an unhandled `Bad_NotImplemented`
+ * from the wire.
+ */
+class AliasNameMethodNotSupportedError extends Error {
+    /** The Method that is missing, by BrowseName. */
+    methodName;
+    /** The category it was looked for on. */
+    categoryNodeId;
+    constructor(methodName, categoryNodeId) {
+        super(`the Server does not expose ${methodName} on ${categoryNodeId.toString()}. ` +
+            "Only FindAlias is mandatory in OPC 10000-17 clause 6.3; the rest are optional.");
+        this.name = "AliasNameMethodNotSupportedError";
+        this.methodName = methodName;
+        this.categoryNodeId = categoryNodeId;
+    }
+}
+exports.AliasNameMethodNotSupportedError = AliasNameMethodNotSupportedError;
+/**
+ * The Server answered a `FindAlias` call with a bad StatusCode.
+ *
+ * Carries the code so a caller can distinguish the cases clause 6.3.2 Table 4
+ * defines — `Bad_InvalidArgument` for a malformed search pattern,
+ * `Bad_ResponseTooLarge` for a result set that needs a narrower filter,
+ * `Bad_UserAccessDenied` for a category the session may not read.
+ */
+class AliasNameCallError extends Error {
+    statusCode;
+    categoryNodeId;
+    constructor(methodName, categoryNodeId, statusCode) {
+        super(`${methodName} on ${categoryNodeId.toString()} failed with ${statusCode.toString()}`);
+        this.name = "AliasNameCallError";
+        this.statusCode = statusCode;
+        this.categoryNodeId = categoryNodeId;
+    }
+}
+exports.AliasNameCallError = AliasNameCallError;
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../source/errors.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAKH;;;;;;;;;;;;;GAaG;AACH,MAAa,gCAAiC,SAAQ,KAAK;IACvD,iDAAiD;IACjC,UAAU,CAAS;IACnC,yCAAyC;IACzB,cAAc,CAAS;IAEvC,YAAY,UAAkB,EAAE,cAAsB;QAClD,KAAK,CACD,8BAA8B,UAAU,OAAO,cAAc,CAAC,QAAQ,EAAE,IAAI;YACxE,gFAAgF,CACvF,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,kCAAkC,CAAC;QAC/C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACzC,CAAC;CACJ;AAfD,4EAeC;AAED;;;;;;;GAOG;AACH,MAAa,kBAAmB,SAAQ,KAAK;IACzB,UAAU,CAAa;IACvB,cAAc,CAAS;IAEvC,YAAY,UAAkB,EAAE,cAAsB,EAAE,UAAsB;QAC1E,KAAK,CAAC,GAAG,UAAU,OAAO,cAAc,CAAC,QAAQ,EAAE,gBAAgB,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC5F,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACzC,CAAC;CACJ;AAVD,gDAUC"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module node-opcua-alias-name-client
+ *
+ * Client-side OPC 10000-17 (AliasNames).
+ *
+ * Resolves the AliasNames **a Server publishes about itself**. Aggregating
+ * AliasNames collected from other Servers (Annexes B and C) and the Annex D
+ * PubSub change notification are out of scope; {@link ServerIndexResolver}
+ * covers the one cross-Server step a Client still has to make, turning the
+ * `ServerIndex` of a returned `ExpandedNodeId` into a URI (Annex A).
+ */
+export { ALIASES_ROOT, type ClientAliasEntry, ClientAliasSet, type ClientAliasVerboseEntry, type FindAliasOptions, TAG_VARIABLES, TOPICS } from "./client_alias_set.js";
+export { AliasNameCallError, AliasNameMethodNotSupportedError } from "./errors.js";
+export { LOCAL_SERVER_INDEX, ServerIndexResolver } from "./server_index_resolver.js";