# OPC UA Part 17 — Alias Names OPC UA Part 17 defines a hierarchy of human-readable **alias names**. Each alias uses a non-hierarchical reference to point to one or more nodes. Clients can search the hierarchy with wildcard patterns and resolve aliases without knowing target NodeIds in advance. This pattern suits tag-naming schemes (PI / SCADA / DCS), pub/sub topic registries, MES integration, and other scenarios where people choose names for machine-addressed nodes. This stack ships full Part 17 support in **`Opc.Ua.Server`** (server side) and **`Opc.Ua.Client`** (client side). The implementation covers: | Spec section | Type / Method | Status | | ------------ | ---------------------------------------- | ------ | | §6.2 | `AliasNameType` (browsable instance nodes) | ✔ opt-in — see below | | §6.3.1 | `AliasNameCategoryType` (incl. nesting) | ✔ (nested instances opt-in — see below) | | §6.3.1 | `LastChange` (`VersionTime`) | ✔ | | §6.3.2 | `FindAlias` | ✔ | | §6.3.3 | `FindAliasVerbose` | ✔ | | §6.3.4 | `AddAliasesToCategory` | ✔ | | §6.3.5 | `DeleteAliasesFromCategory` | ✔ | | §7.2 | `AliasNameDataType` | ✔ | | §7.3 | `AliasNameVerboseDataType` | ✔ | | §8.2 | `AliasFor` reference type | ✔ | | §9.2 | Well-known `Aliases (i=23470)` | ✔ wired; optional methods opt-in — see below | | §9.3 | Well-known `TagVariables (i=23479)` | ✔ wired; optional methods opt-in — see below | | §9.4 | Well-known `Topics (i=23488)` | ✔ wired; optional methods opt-in — see below | | Annex D | PubSub replication (LastChange notifications) | ✔ transport-agnostic — see below | ## Contents - [Server side](#server-side--opcuaserveraliasnames) - [Quick start — serving standard categories](#quick-start--serving-standard-categories) - [Quick start — application-defined categories](#quick-start--application-defined-categories) - [Browsable alias nodes](#browsable-alias-nodes) - [Custom backend](#custom-backend) - [Client side](#client-side--opcuaclientaliasnames) - [`AliasNameResolver`](#aliasnameresolver--cached-aliasnodeid) - [Spec deviations / wrinkles](#spec-deviations--wrinkles) - [Annex D — PubSub LastChange notifications](#annex-d--pubsub-lastchange-notifications) - [Server-side PubSub](#server-side--opcuaserveraliasnamespubsub) - [Client-side PubSub](#client-side--opcuaclientaliasnamespubsub) - [See also](#see-also) ## Server side — `Opc.Ua.Server.AliasNames` Search patterns use the shared `LikePattern` parser and matcher, with case-sensitive whole-string matching. Backslashes escape literal characters both inside and outside character sets. `[^...]` negates a set; `[!...]` remains accepted for compatibility. Wildcards match line breaks. Trailing escapes, malformed sets, descending ranges, and unescaped `^` outside the start of a set return `BadInvalidArgument` from both FindAlias variants even with an empty store. All alias matches in one search share a 100 ms deadline; exceeding it returns `BadTimeout`. The server also checks for request cancellation before matching the next name. The server library exposes a pluggable backend (`IAliasNameStore`) plus a default in-memory implementation. Apps assemble their alias inventory inside a store, then either: 1. Register the store through `AddAliasNameStore(...)` on the DI server builder, or directly with the server-wide `IAliasNameStoreRegistry`, so the standard well-known `Aliases`/`TagVariables`/`Topics` nodes start dispatching through it, **or** 2. Wrap the store in an `AliasNameNodeManager` to expose application- defined categories under a custom namespace (with full `AddAliasesToCategory` / `DeleteAliasesFromCategory` support). Both approaches can be combined. ### Quick start — serving standard categories ```csharp using Microsoft.Extensions.DependencyInjection; using Opc.Ua; using Opc.Ua.Server.AliasNames; var tagVariables = new AliasNameCategoryDescriptor( ObjectIds.TagVariables, QualifiedName.From(BrowseNames.TagVariables), AliasNameCapabilities.FindAliasVerbose); var store = new InMemoryAliasNameStore([tagVariables]); store.Seed(ObjectIds.TagVariables, "ServerCurrentTime", new ExpandedNodeId(VariableIds.Server_ServerStatus_CurrentTime), serverUri: null, referenceTypeId: ReferenceTypeIds.AliasFor); services.AddOpcUa() .AddServer(options => { options.ApplicationName = "AliasServer"; options.EndpointUrls.Add("opc.tcp://localhost:4840/AliasServer"); }) .AddAliasNameStore(store) .ConfigureAliasNames(options => options.MaterializeAliasNodes = true); ``` `AddAliasNameStore(...)` and `AddAliasNameStoreRegistry(...)` register their stores before address-space startup, after application `IServerPreStartupTask` registrations have finished initializing source registries. The opt-in `ConfigureAliasNames(Action)` extension is on `IOpcUaServerBuilder` in `Microsoft.Extensions.DependencyInjection`. `AliasNameServerOptions` is in `Opc.Ua.Server.AliasNames`, and its `MaterializeAliasNodes` property defaults to `false`. `RefreshAliasNodesOnChange` separately defaults to `true`, keeping the browse view current whenever materialization is enabled. When enabled, the normal `ConfigurationNodeManager` materializes registered standard-category aliases and their declared optional capabilities after the standard nodes have loaded. No server or diagnostics-node-manager subclass is needed. The same setting applies to stores for `Topics`; their targets must be `PublishedDataSetType` instances. Omit `ConfigureAliasNames(...)` when only method-based lookup is needed. Initial node materialization retries one timed-out snapshot read before creating nodes for that root. The retry is logged; each attempt retains the 100 ms search limit. Repeated timeouts, other store errors, and cancellation still abort startup. Only initial materialization uses this immediate retry. When a client calls `Aliases.FindAlias` (`i=23476`), `TagVariables.FindAlias` (`i=23485`) or `Topics.FindAlias` (`i=23494`), `DiagnosticsNodeManager`'s late binder routes the call through the registry to the matching store. Direct `IAliasNameStoreRegistry` registration remains available for custom hosting. Register stores before the materialization pass when their aliases must also be browsable. ### Quick start — application-defined categories `AliasNameNodeManager` is a `CustomNodeManager2` that owns a namespace and creates its own category tree from the store's `RootCategories`. Add it to your server's node-manager list: ```csharp var myRoot = new AliasNameCategoryDescriptor( new NodeId("My/Category", myNamespaceIndex), new QualifiedName("My/Category", myNamespaceIndex), AliasNameCapabilities.All); // expose every optional method var store = new InMemoryAliasNameStore([myRoot]); nodeManagers.Add(new AliasNameNodeManager(server, configuration, store)); ``` Options: * `NamespaceUri` — controls the namespace under which the manager registers its category instances. Defaults to `http://opcfoundation.org/UA/AliasName/`. Every category descriptor's NodeId must lie in this namespace; descriptors pointing anywhere else are skipped with a warning rather than claiming another manager's ids. * `MaterializeAliasNodes` (default `true`, unchanged for `AliasNameNodeManagerOptions`) — creates one browsable `AliasNameType` node per alias, with `AliasFor` references to its targets, exactly as the standard-node materialization below does. Disable to expose only the category tree. * `LinkToStandardAliasesObject` (default `true`) — adds `Organizes` external references from the well-known `Aliases (i=23470)` object to the manager's root categories so they show up in the standard browse tree. * `RequireSecurityAdminForMutations` (default `true`) — rejects `AddAliasesToCategory` / `DeleteAliasesFromCategory` calls from unauthenticated users or sessions without the `WellKnownRole_SecurityAdmin` role on a `SignAndEncrypt` channel. * `RegisterWithServerRegistry` (default `true`) — also registers the store with `IAliasNameStoreRegistry` so the well-known standard nodes see it. ### Browsable alias nodes Registering a store makes `FindAlias` answer from it, but the aliases themselves stay inside the store — nothing in the address space shows them. Part 17 §6.2 clients (the OPC Foundation CTT among them) also *browse* for aliases, so a server under conformance test needs the alias hierarchy materialized as real nodes. Both materialization paths — `AliasNameNodeManager` for application-defined namespaces and `DiagnosticsNodeManager.MaterializeRegisteredAliasNameNodesAsync` for the standard well-known nodes — run the same shared walker (`AliasNameNodeMaterializer`), so they produce structurally identical Part 17 trees and every fix lands in both at once. For the standard DI server, `ConfigureAliasNames(options => options.MaterializeAliasNodes = true)` makes the normal `ConfigurationNodeManager` invoke that helper. Its default is `false`, independent of the custom `AliasNameNodeManagerOptions` default of `true`. Metadata, resource, and alias configuration use the `DependencyInjectionStandardServer` hooks; a non-DI custom `AddServer()` rejects these DI-only settings rather than silently ignoring them. `DiagnosticsNodeManager.MaterializeRegisteredAliasNameNodesAsync` materializes every registered store. For each alias, it creates an `AliasNameType` instance whose BrowseName is the alias name. It adds `AliasFor` references to the alias targets and inverse `HasAlias` references to local targets. The method also creates an `AliasNameCategoryType` instance for every store category absent from the standard NodeSet, including nested categories. It organizes a root category under the standard `Aliases` object so clients can browse to it. For each remote target, the manager registers its server URI in the server's `ServerUris` table and uses the matching `ServerIndex`. The manager moves server-defined BrowseNames in namespace 0, reserved for OPC Foundation names, to the diagnostics namespace. Part 17 clients compare alias names without considering the namespace, so this change is transparent. The pass is idempotent and creates category nodes only when their NodeId lies in the diagnostics namespace. If a descriptor points elsewhere, the manager skips that category with a warning rather than claiming IDs owned by another manager or the standard NodeSet. Custom diagnostics-node-manager implementations can still call the helper from an overridden `CreateAddressSpaceAsync`, after `base` has loaded the standard categories: ```csharp public override async ValueTask CreateAddressSpaceAsync( IDictionary> externalReferences, CancellationToken cancellationToken = default) { await base.CreateAddressSpaceAsync(externalReferences, cancellationToken) .ConfigureAwait(false); await MaterializeRegisteredAliasNameNodesAsync( externalReferences, cancellationToken).ConfigureAwait(false); } ``` The same pass also creates the **optional Part 17 members** `FindAliasVerbose`, `AddAliasesToCategory`, `DeleteAliasesFromCategory`, and `LastChange` for each category whose descriptor declares them through `AliasNameCapabilities`. This includes well-known categories for which the standard NodeSet does not declare these members: ```csharp var tagVariables = new AliasNameCategoryDescriptor( ObjectIds.TagVariables, QualifiedName.From(BrowseNames.TagVariables), AliasNameCapabilities.All); // verbose + add + delete + LastChange ``` Mutation calls are gated on a `SecurityAdmin` caller over a `SignAndEncrypt` channel and return `BadUserAccessDenied` otherwise. Standard-category materialization is opt-in: servers that only need `FindAlias` to answer from their store do not create alias instance nodes. Once materialized, both standard and application-defined alias nodes follow store changes by default. Aliases added or removed through `AddAliasesToCategory` / `DeleteAliasesFromCategory` update queries, advance `LastChange`, and schedule reconciliation of `AliasNameType` nodes and their target references. `RefreshAliasNodesOnChange` defaults to `true` on both `AliasNameServerOptions` and `AliasNameNodeManagerOptions`. Set it to `false` explicitly to retain a startup-only browse snapshot. It never overrides `MaterializeAliasNodes = false`: ```csharp builder.ConfigureAliasNames(options => { options.MaterializeAliasNodes = true; }); ``` Each live-materialization host owns one background worker and at most one pending refresh signal. Category and ancestor notifications coalesce into a single pass over store roots. The worker applies a completed query only if its generation is current. If a query fails, it leaves existing nodes and references intact and logs the failure. The worker retains unchanged node instances, updates only changed associations, and applies inverse `HasAlias` references to their actual local targets. It reads `LastChange` from the current store version, not a possibly delayed event value, including across counter rollover. During asynchronous host disposal, the host cancels and drains the worker. Disposal waits up to five seconds and logs a warning if a provider does not stop. The browse view materializes only `AliasFor` associations. If a store holds an entry under an unrelated reference type, the entry is not a Part 17 §6.2 alias association. `FindAlias` can return it when the filter matches, but the materializer does not create an alias node for it. The materializer also creates entries stored under an `AliasFor` subtype, but uses the base `AliasFor` reference because the verbose record does not carry the concrete reference type. Two things the caller controls: * Give each category descriptor a BrowseName in a namespace owned by the server. The store assigns that namespace to every alias `QualifiedName` it reports. The materializer also moves `ns=0` BrowseNames out of the reserved OPC Foundation namespace. Using a server-owned namespace keeps query results and browsable nodes aligned, so `TranslateBrowsePathsToNodeIds` resolves returned alias names. The reference server uses the diagnostics namespace for all its descriptors. * Part 17 §9 requires `Topics` aliases to target `PublishedDataSetType`. The store and `AddAliasesToCategory` do not enforce this constraint. If a server exposes mutation methods on `Topics`, grant access only to operators who preserve it. `Quickstarts.ReferenceServer` applies these rules in `ReferenceServerConfigurationNodeManager`. The manager creates `PublishedDataSet` instances and seeds the `Topics` aliases in the same component. An alias therefore cannot target a dataset that the manager did not create. `ReferenceServer.ConfigureAliasNameStore` seeds the nested `Devices` sub-category under `TagVariables`. ### Custom backend Implement `IAliasNameStore` to back the alias inventory with your own storage (DB, file, MES, …). The interface is small: ```csharp public interface IAliasNameStore { IReadOnlyList RootCategories { get; } event EventHandler? Changed; uint? GetLastChange(NodeId categoryId); bool OwnsCategory(NodeId categoryId); ValueTask> FindAliasAsync(...); ValueTask> FindAliasVerboseAsync(...); ValueTask AddAliasesAsync(...); ValueTask DeleteAliasesAsync(...); } ``` The reference `InMemoryAliasNameStore` is thread-safe (SemaphoreSlim), supports nested categories and emits `Changed` events that bubble up to the address-space `LastChange` property. A mutation on a nested category bumps — and notifies for — every ancestor category as well, per Part 17 §6.3.1/§9.2: a category's `LastChange` reflects the most recent change anywhere in its subtree, and the root `Aliases` value reflects any change at all. ## Client side — `Opc.Ua.Client.AliasNames` The client library provides a high-level `AliasNameClient` plus a caching `AliasNameResolver`. ```csharp using Opc.Ua.Client.AliasNames; // Standard categories have hardcoded method NodeIds so the first call // is one round-trip — no extra TranslateBrowsePaths probe needed. AliasNameClient client = AliasNameClient.OpenStandardTagVariables(session); IReadOnlyList result = await client.FindAliasAsync("TIC%", referenceTypeFilter: null, ct); ``` `AliasNameClient` exposes the full Part 17 method surface: * `FindAliasAsync(pattern, referenceTypeFilter, ct)` * `FindAliasVerboseAsync(...)` — throws `NotSupportedException` when the category does not expose the optional method. * `AddAliasesToCategoryAsync(IEnumerable, ct)` * `DeleteAliasesFromCategoryAsync(IEnumerable, ct)` * `EnumerateSubCategoriesAsync(ct)` — `IAsyncEnumerable` of child `AliasNameSubCategoryInfo`, including children whose type is a subtype of `AliasNameCategoryType`. * `ReadLastChangeAsync(ct)` — returns the `VersionTime` (or `null` when the category does not expose `LastChange`). Per-call errors map to typed exceptions: | Status code | Exception | | -------------------------- | ----------------------------------- | | `BadUserAccessDenied` | `UnauthorizedAccessException` | | `BadNotSupported` | `NotSupportedException` | | `BadNotImplemented` | `NotSupportedException` | | other `BadXxx` | `ServiceResultException` | ### `AliasNameResolver` — cached alias→NodeId ```csharp await using var resolver = new AliasNameResolver( AliasNameClient.OpenStandardTagVariables(session)); IReadOnlyList targets = await resolver.ResolveAsync("TIC101_Setpoint", ct); string aliasName = await resolver.ResolveAliasNameAsync(targets[0], ct); ``` Default refresh mode is `Manual` — callers invoke `RefreshAsync` (or rely on lazy-load via `ResolveAsync`). Opt in to automatic cache invalidation via one of: | `AliasNameResolverRefreshMode` | Strategy | When to use | | ---------------------------------- | ----------------------------------------- | ----------- | | `Manual` (default) | `ManualAliasNameRefreshStrategy` | Caller drives refresh explicitly. Safe everywhere. | | `AutoOnLastChangePolling` | `PollingAliasNameRefreshStrategy` | Server lacks Subscriptions or you want a fixed `Read` cadence. | | `AutoOnLastChangeMonitoredItem` | `MonitoredItemAliasNameRefreshStrategy` | Server supports Subscriptions. Push-based — no `Read` per interval. | Custom strategies (e.g. the Annex D PubSub bridge in `Opc.Ua.Client.AliasNames.PubSub` — see Annex D below) plug in via: ```csharp new AliasNameResolverOptions { RefreshStrategy = new MyCustomStrategy() // takes precedence over RefreshMode } ``` The `IAliasNameRefreshStrategy` contract is tiny: ```csharp public interface IAliasNameRefreshStrategy : IAsyncDisposable { ValueTask StartAsync(AliasNameClient client, Action onInvalidate, CancellationToken ct); } ``` Implementations watch for stale-cache triggers and invoke `onInvalidate` when they detect a change. `MonitoredItemAliasNameRefreshStrategyOptions` controls subscription ownership. By default, the strategy creates and deletes the underlying `Subscription`. Set `SharedSubscription` to use an externally managed subscription for the monitored item. Disposing the resolver (`await using` / `DisposeAsync`) tears down the strategy: timer for polling, `MonitoredItem` + `Subscription` for the monitored-item variant. Disposal is idempotent and never throws. ## Spec deviations / wrinkles * **`AliasNameDataType.ReferencedNodes`** — the wire format defines this as `ExpandedNodeId[]` (NodeSet `i=18`), not `NodeId[]`. The source-generated `AliasNameDataType` is correct; the historical Quickstart sample used `NodeId[]` and has been removed. * **Standard well-known nodes** — the OPC UA NodeSet instantiates only `FindAlias` on `Aliases`/`TagVariables`/`Topics` (plus `LastChange` on `Aliases`), so the always-on binder wires just those. The optional methods are added by `MaterializeRegisteredAliasNameNodesAsync` through the generated `AddFindAliasVerbose` / `AddAddAliasesToCategory` / `AddDeleteAliasesFromCategory` optional- child helpers, for each category whose descriptor declares the matching `AliasNameCapabilities`. Each child is created at the NodeId the OPC Foundation reserves for it (`Aliases.FindAliasVerbose` = `i=24054`, `TagVariables.LastChange` = `i=32854`, and so on). The standard identifier registry (`StandardTypes.csv`) allocates these identifiers, but the ModelDesign does not declare the optional children and the published NodeSet does not include them. The standard address space therefore does not instantiate them. A reserved ID is available if a server chooses to expose a node; it does not require the server to create that node. The source generator therefore emits no parent-to-instance mapping or `MethodIds` constant for these children. `DiagnosticsNodeManager.ReservedChildIds` supplies nine method IDs and the two missing `LastChange` IDs explicitly, each traceable to its registry row. The argument properties have generated `VariableIds` constants, which the implementation uses to reference them. Do not add these children to `StandardTypes.xml`. That file copies the OPC Foundation ModelDesign verbatim and is synchronized from upstream. A local edit would be lost on the next sync, and the NodeIds would revert to factory-minted values. * **`AliasNameCapabilities.AddAliasesToCategory` / `DeleteAliasesFromCategory`** — on an `AliasNameNodeManager` this defaults to `SecurityAdmin`-only via `AliasNameNodeManagerOptions.RequireSecurityAdminForMutations`; on the standard well-known nodes the same check is always applied and cannot be opted out of. It requires both the role grant AND a `SignAndEncrypt` channel. * **`ReferenceTypeFilter` semantics** — null/empty and `ReferenceTypeIds.References` match every alias regardless of reference type. Otherwise matches are limited to aliases whose reference type is, or is a subtype of, the filter (using `Server.TypeTree.IsTypeOf`). ## Annex D — PubSub LastChange notifications Part 17 Annex D defines a lightweight PubSub schema for alias-change notifications between servers. The schema carries only each category's current `LastChange` value (a `VersionTime`/`uint`) — subscribers learn that a publisher's category changed, then refetch alias contents via `FindAlias`/`FindAliasVerbose` if needed. The data types (already emitted by the source generator): | NodeId | Type | Fields | | -------- | ----------------------------- | ------ | | `i=24052` | `AliasCategoryUpdateDataType` | `Category : PortableNodeId`, `LastChange : VersionTime` | | `i=24053` | `AliasUpdateDataType` | `ApplicationUri : string`, `Categories : AliasCategoryUpdateDataType[]` | ### Server side — `Opc.Ua.Server.AliasNames.PubSub` The server library exposes a transport-agnostic publisher that emits fully-built `AliasUpdateDataType` messages whenever an `IAliasNameStoreRegistry`-tracked store changes: ```csharp using Opc.Ua.Server.AliasNames; using Opc.Ua.Server.AliasNames.PubSub; // inside server startup (after the alias store is registered): var resolver = new ServerPortableNodeIdResolver(server); var publisher = new AliasNamePublisher( registry: ((IAliasNameStoreRegistryProvider)server).AliasNameStoreRegistry, portableResolver: resolver, applicationUri: configuration.ApplicationUri); publisher.AliasUpdateProduced += (_, e) => { // Hand `e.Update` to your transport — e.g. publish a DataSetMessage // through Opc.Ua.PubSub.UaPubSubApplication with the DataSet // built by AliasUpdateDataSetFactory.Create(...). }; ``` Helpers shipped: * `IPortableNodeIdResolver` + `ServerPortableNodeIdResolver` — converts a local `NodeId` into the spec-required `PortableNodeId` (NamespaceUri + Identifier with namespace index stripped). * `AliasUpdateDataSetFactory.Create(dataSetClassId)` — builds the fixed-by-spec `DataSetMetaDataType` describing the `AliasUpdate` DataSet (`ApplicationUri : string`, `Categories : AliasCategoryUpdateDataType[]`). * `AliasNamePublisher` — subscribes to the registry, builds and emits `AliasUpdateDataType` messages via the `AliasUpdateProduced` event. The library deliberately stays transport-agnostic: it raises the fully-built `AliasUpdateDataType` and lets the application wire it into `Opc.Ua.PubSub.UaPubSubApplication` (UDP / JSON / MQTT) or any other transport that can carry the `AliasUpdateDataType` payload. ### Client side — `Opc.Ua.Client.AliasNames.PubSub` The client library mirrors the publisher: ```csharp using Opc.Ua.Client.AliasNames; using Opc.Ua.Client.AliasNames.PubSub; var reader = new AliasNamePubSubReader( new AliasNamePubSubReaderOptions { ExpectedApplicationUri = "urn:opcfoundation:publisher", }); // Hand incoming AliasUpdateDataType messages off to the reader from // your transport (e.g. UaPubSubApplication.DataReceived, an MQTT // subscriber callback, ...): reader.Submit(receivedAliasUpdate); // Wire reader into the resolver so the cache invalidates on every // LastChange bump observed via PubSub. await using var resolver = new AliasNameResolver( AliasNameClient.OpenStandardAliases(session), new AliasNameResolverOptions { RefreshStrategy = new AliasNamePubSubRefreshStrategy(reader), }); ``` Helpers shipped: * `AliasNamePubSubReader` — surfaces incoming `AliasUpdateDataType` messages as the `AliasUpdateReceived` event. Optional `ExpectedApplicationUri` filter drops messages from other publishers. * `AliasNamePubSubRefreshStrategy : IAliasNameRefreshStrategy` — bridges the reader into the resolver. Matches incoming entries by the resolver's category `NamespaceUri` + identifier; fires `Invalidate` on any value-difference (wrap-safe — the comparison is inequality, not strict greater-than). The PubSub bridge plugs into the same `IAliasNameRefreshStrategy` extension point as the polling and monitored-item strategies — apps can mix-and-match, e.g. fall back to polling on a particular category while letting PubSub drive the rest. ## See also * OPC UA Part 17 specification: https://reference.opcfoundation.org/v105/Core/docs/Part17/ * [Asset Management Basics](AMB.md#discovery) — the OPC 10000-110 categories `Assets`, `AssetsByProductInstanceUri` and `AssetsByAssetId`, which the AMB node manager serves with a registry of its own; `FindAlias` on `0:Aliases` does not search them. * [Dependency Injection](DependencyInjection.md#alias-name-stores-and-standard-browse-nodes) — hosted store registration and standard-category materialization. * `tools/Opc.Ua.SourceGeneration.Core/Design/StandardTypes.xml` — Part 17 type definitions consumed by the source generator. * `tests/Opc.Ua.Server.Tests/AliasNames/` — server-side unit tests. * `tests/Opc.Ua.Client.Tests/AliasNames/` — mocked-session and live integration tests. * `samples/Quickstarts.Servers/ReferenceServer/ReferenceServer.cs` — `ConfigureAliasNameStore` shows how to seed and register a store.