Client

Client-side API: sessions, subscriptions, and service calls.

ua::client::AddressSpaceCachePolicy

Per-Connection tunables for the optional client-side address-space cache (section 8.7).

The cache trades a bounded amount of client memory for fewer server round-trips: it substitutes server-assigned numeric handles (RegisterNodes) into repeated access operations, caches the static attributes tier-2 pre-flights against, and optionally caches Browse results for repeated subtree walks. It is opt-in: when enabled is false the cache is a clean pass-through no-op and every operation goes wire-direct.

The numeric defaults are the frozen SDK policy choices (client design section 9.8.2), not spec-mandated; real workloads override them here.

Public attributes

bool enabled

Master switch.

bool useRegisterNodes

When true, repeated access to a Node auto-registers it (RegisterNodes) and substitutes the returned numeric alias into later requests (CL-VIEW-009).

std::size_t maxRegisteredNodes

Ceiling on the RegisterNodes alias sub-cache; the least-recently-used alias is evicted (and its node queued for UnregisterNodes) past this (section 9.8.2).

std::size_t maxCachedAttributes

Ceiling on the static-attribute sub-cache (ArrayDimensions / AccessLevelEx / DataType / ValueRank / AccessLevel / UserAccessLevel) that drives tier-2 pre-flight (section 9.8.2).

std::size_t maxCachedBrowses

Ceiling on the Browse-result sub-cache that accelerates repeated BrowseCursor walks (section 9.8.2).

std::size_t unregisterBatchSize

The evicted/explicitly-released nodes are coalesced into one UnregisterNodes call once this many have accumulated (whichever comes first with unregisterCoalesceWindow) (section 9.8.2, CL-VIEW-010).

std::chrono::milliseconds unregisterCoalesceWindow

The single-armed-with-rearm coalesce window: a steady stream of evictions never flushes the pending UnregisterNodes batch until the stream quiets for this long (section 9.8.2, CL-VIEW-010).

std::chrono::seconds browseEntryTtl

Idle time-to-live for a cached Browse result; a lookup treats an older entry as a miss and drops it (section 9.8.2).

ua::client::AlarmConditionTrackerPolicy

Per-Connection knobs for the tracker (section 8.8.1).

Public attributes

bool preferConditionRefresh2

The prefer condition refresh2.

std::size_t methodCacheCapacity

The method cache capacity.

std::size_t maxTimeShelvedCacheCapacity

The max time shelved cache capacity.

bool refreshOnRedundancySwitch

The refresh on redundancy switch.

ua::client::TrackedKey

A tracked condition/branch key: trunk (branchId empty == NULL) and prior-state branches are INDEPENDENT entries (CL-AC-002).

Functions

bool operator==(const TrackedKey &) const =default

Returns: True when the requested condition is satisfied. Supports value-handle comparison or assignment.

Public attributes

ua::NodeId conditionId

The condition id.

ua::NodeId branchId

The ConditionBranch this entry tracks; a NULL NodeId is the trunk (the condition's current state).

ua::client::TwoStateValue

A TwoStateVariableType sub-state value (CL-AC-016).

id == true means the "true" state is current.

Public attributes

std::optional< bool > id

The id.

std::optional< ua::DateTime > transitionTime

The transition time.

std::optional< ua::LocalizedText > effectiveDisplayName

The effective display name.

ua::client::DiscreteAlarmInfo

Marker payload for DiscreteAlarmType itself, which adds no properties beyond AlarmConditionType (CL-AC-021).

ua::client::OffNormalAlarmInfo

OffNormalAlarmType-family payload (also Trip, SystemOffNormal, and CertificateExpiration).

The property is mandatory in a conforming event model; optionality preserves the distinction when a malformed or incomplete server event omitted it (CL-AC-021).

Public attributes

std::optional< ua::NodeId > normalState

The normal state.

ua::client::DiscrepancyAlarmInfo

DiscrepancyAlarmType payload.

TargetValueNode and ExpectedTime are mandatory server properties; Tolerance is optional. Optional members preserve wire absence/malformed-type information (CL-AC-021).

Public attributes

std::optional< ua::NodeId > targetValueNode

The target value node.

std::optional< ua::Duration > expectedTime

The expected time.

std::optional< double > tolerance

The tolerance.

ua::client::AlarmRateMetric

Public alarm rate metric API.

Public attributes

double value

The value.

std::uint16_t rateMinutes

The rate minutes.

ua::client::AlarmMetricsSnapshot

Public alarm metrics snapshot API.

Public attributes

std::uint32_t alarmCount

The alarm count.

ua::DateTime startTime

The start time.

ua::Duration maximumActiveState

The maximum active state.

ua::Duration maximumUnAck

The maximum un ack.

AlarmRateMetric currentAlarmRate

The current alarm rate.

AlarmRateMetric maximumAlarmRate

The maximum alarm rate.

std::uint32_t maximumReAlarmCount

The maximum re alarm count.

AlarmRateMetric averageAlarmRate

The average alarm rate.

ua::client::AlarmMetricsView

Public alarm metrics view API.

Functions

AlarmMetricsView()=default

void read_all_async(std::function< void(ua::Result< AlarmMetricsSnapshot >)> callback) noexcept

• callback (std::function< void(ua::Result< AlarmMetricsSnapshot >)>) - Completion callback that receives the operation result. Asynchronously read all.

AlarmMetricsSnapshot read_all_sync()

Returns: The requested value. Synchronously read all.

ua::Result< AlarmMetricsSnapshot > try_read_all_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to read all sync without throwing.

void reset_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously reset.

void reset_sync()

Synchronously reset.

ua::VoidResult try_reset_sync() noexcept

Returns: The requested value. Attempts to reset sync without throwing.

ua::client::TrackedCondition

The tracked state of one condition/branch (section 8.8).

Public attributes

TrackedKey key

The key.

ua::NodeId conditionTypeId

most-derived EventType

ua::LocalizedText conditionName

The condition name.

ua::NodeId conditionClassId

mandatory ConditionType class identifier (CL-AC-014)

ua::LocalizedText conditionClassName

mandatory human-readable class name (CL-AC-014)

ua::ByteString lastEventId

CL-AC-019 - updated on every inbound event for the key.

std::uint16_t severity

The severity.

ua::LocalizedText message

The message.

ua::DateTime time

The time.

ua::DateTime receiveTime

CL-AC-005 ordering source.

ua::NodeId sourceNode

The source node.

ua::String sourceName

The source name.

bool retain

CL-AC-006 - false to removed.

std::optional< ua::LocalizedText > comment

The comment.

TwoStateValue enabledState

The enabled state.

std::optional< TwoStateValue > ackedState

The acked state.

std::optional< TwoStateValue > confirmedState

The confirmed state.

std::optional< TwoStateValue > activeState

The active state.

AlarmSubtypeInfo subtypeInfo

Typed payload selected from the exact EventType for Discrete/OffNormal/Discrepancy families (CL-AC-021).

std::optional< TwoStateValue > suppressedState

The suppressed state.

std::optional< TwoStateValue > outOfServiceState

The out of service state.

std::optional< TwoStateValue > silenceState

The silence state.

std::optional< TwoStateValue > latchedState

The latched state.

std::optional< bool > suppressedOrShelved

The suppressed or shelved.

std::optional< ua::LocalizedText > shelvingState

ShelvingState.CurrentState (surfaced only)

std::optional< ua::Duration > reAlarmTime

The re alarm time.

std::optional< std::int16_t > reAlarmRepeatCount

The re alarm repeat count.

std::optional< ua::Duration > onDelay

The on delay.

std::optional< ua::Duration > offDelay

The off delay.

std::optional< bool > audibleEnabled

The audible enabled.

std::optional< ua::AudioDataType > audibleSound

The audible sound.

std::optional< bool > firstInGroupFlag

The first in group flag.

std::optional< ua::NodeId > firstInGroup

The first in group.

std::optional< double > highHighLimit

ExclusiveLimit / LimitAlarm thresholds (CL-AC-023).

std::optional< double > highLimit

The high limit.

std::optional< double > lowLimit

The low limit.

std::optional< double > lowLowLimit

The low low limit.

std::optional< TwoStateValue > lowLowState

NonExclusiveLimitAlarm concurrent limit-state active flags (CL-AC-025).

std::optional< TwoStateValue > lowState

The low state.

std::optional< TwoStateValue > highState

The high state.

std::optional< TwoStateValue > highHighState

The high high state.

std::optional< ua::LocalizedText > exclusiveLimitState

ExclusiveLimitStateMachine CurrentState (LimitState) - surfaced only (CL-AC-024).

std::optional< double > maxTimeShelved

The alarm's MaxTimeShelved (milliseconds) when the event carried it.

ua::client::AlarmConditionTrackerInfo

Cross-strand observability snapshot of the tracker (section 8.8.1).

Public attributes

std::size_t trackedConditionCount

The tracked condition count.

std::size_t openRefreshWindowCount

The open refresh window count.

bool pendingFollowOnRefresh

The pending follow on refresh.

bool useRefresh2

The use refresh2.

ua::client::AlarmHandle

A per-condition ACTIONABLE handle (T30): callers act on a condition object directly instead of round-tripping an opaque TrackedKey back through the tracker.

Move/copy-cheap value handle (weak tracker back-ref, strong-locked per call; mKey identifies the branch). Every method forwards to the tracker's strand; refresh + observer registration stay on the tracker.

Functions

AlarmHandle()=default

TrackedKey key() const

Returns: The requested value. Returns or updates the key.

void acknowledge_async(std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously acknowledge.

void acknowledge_sync(std::optional< ua::LocalizedText > comment)

• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously acknowledge. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_acknowledge_sync(std::optional< ua::LocalizedText > comment) noexcept

• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to acknowledge sync without throwing.

void confirm_async(std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously confirm.

void confirm_sync(std::optional< ua::LocalizedText > comment)

• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously confirm. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_confirm_sync(std::optional< ua::LocalizedText > comment) noexcept

• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to confirm sync without throwing.

void add_comment_async(ua::ByteString eventId, std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• eventId (ua::ByteString) - Event identifier required by the condition method.
• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously add comment.

void add_comment_sync(ua::ByteString eventId, std::optional< ua::LocalizedText > comment)

• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously add comment. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_add_comment_sync(ua::ByteString eventId, std::optional< ua::LocalizedText > comment) noexcept

• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to add comment sync without throwing.

void enable_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously enable.

void enable_sync()

Synchronously enable.

ua::VoidResult try_enable_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to enable sync without throwing.

void disable_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously disable.

void disable_sync()

Synchronously disable.

ua::VoidResult try_disable_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to disable sync without throwing.

void silence_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously silence.

void silence_sync()

Synchronously silence.

ua::VoidResult try_silence_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to silence sync without throwing.

void suppress_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously suppress.

void suppress_sync()

Synchronously suppress.

ua::VoidResult try_suppress_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to suppress sync without throwing.

void unsuppress_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously unsuppress.

void unsuppress_sync()

Synchronously unsuppress.

ua::VoidResult try_unsuppress_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to unsuppress sync without throwing.

void shelve_async(std::optional< ua::Duration > shelvingTime, std::function< void(ua::VoidResult)> callback) noexcept

• shelvingTime (std::optional< ua::Duration >) - The shelving time.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously shelve.

void shelve_sync(std::optional< ua::Duration > shelvingTime)

• shelvingTime (std::optional< ua::Duration >) - The shelvingtime. Synchronously shelve. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_shelve_sync(std::optional< ua::Duration > shelvingTime) noexcept

• shelvingTime (std::optional< ua::Duration >) - The shelvingtime.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to shelve sync without throwing.

void unshelve_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously unshelve.

void unshelve_sync()

Synchronously unshelve.

ua::VoidResult try_unshelve_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to unshelve sync without throwing.

void read_property_async(ua::QualifiedName property, std::function< void(ua::Result< ua::Variant >)> callback) noexcept

• property (ua::QualifiedName) - Property browse name.
• callback (std::function< void(ua::Result< ua::Variant >)>) - Completion callback that receives the operation result. Reads a current child property/value directly from the condition instance. This is the fallback for plain AlarmConditionType Properties whose mutation is not guaranteed to generate an Event.

ua::Variant read_property_sync(ua::QualifiedName property)

• property (ua::QualifiedName) - Property browse name.

Returns: The requested value. Synchronously read property.

ua::Result< ua::Variant > try_read_property_sync(ua::QualifiedName property) noexcept

• property (ua::QualifiedName) - Property browse name.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to read property sync without throwing.

ua::client::AlarmConditionTracker

The public value handle (move-only shared_ptr pimpl) over the co-owned private sub-object detail::AlarmConditionTrackerImpl (T23).

Lifecycle (construction, start, close, reconnect) is NOT on this handle - it is driven by detail::EventSubscriberImpl. This handle exposes only the consumer surface; every method forwards one-hop to the co-owned Impl.

Functions

AlarmConditionTracker(AlarmConditionTracker &&) noexcept=default

Returns or updates the alarm condition tracker.

AlarmConditionTracker & operator=(AlarmConditionTracker &&) noexcept=default

Returns: A reference to this object. Supports value-handle comparison or assignment.

~AlarmConditionTracker()=default

std::shared_ptr< const AlarmConditionTrackerInfo > info() const noexcept

Returns: An immutable snapshot of the current state. Returns or updates the info.

void on_condition_added_async(ConditionAddedCb cb, std::function< void(ua::VoidResult)> callback) noexcept

• cb (ConditionAddedCb) - Observer callback to register.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously on condition added.

void on_condition_added_sync(ConditionAddedCb cb)

• cb (ConditionAddedCb) - The cb. Synchronously on condition added. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_on_condition_added_sync(ConditionAddedCb cb) noexcept

• cb (ConditionAddedCb) - The cb.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to on condition added sync without throwing.

void on_condition_changed_async(ConditionChangedCb cb, std::function< void(ua::VoidResult)> callback) noexcept

• cb (ConditionChangedCb) - Observer callback to register.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously on condition changed.

void on_condition_changed_sync(ConditionChangedCb cb)

• cb (ConditionChangedCb) - The cb. Synchronously on condition changed. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_on_condition_changed_sync(ConditionChangedCb cb) noexcept

• cb (ConditionChangedCb) - The cb.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to on condition changed sync without throwing.

void on_condition_removed_async(ConditionRemovedCb cb, std::function< void(ua::VoidResult)> callback) noexcept

• cb (ConditionRemovedCb) - Observer callback to register.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously on condition removed.

void on_condition_removed_sync(ConditionRemovedCb cb)

• cb (ConditionRemovedCb) - The cb. Synchronously on condition removed. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_on_condition_removed_sync(ConditionRemovedCb cb) noexcept

• cb (ConditionRemovedCb) - The cb.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to on condition removed sync without throwing.

void list_conditions_async(std::function< void(ua::Result< std::vector< TrackedCondition > >)> callback) noexcept

• callback (std::function< void(ua::Result< std::vector< TrackedCondition > >)>) - Completion callback that receives the operation result. Asynchronously list conditions.

std::vector< TrackedCondition > list_conditions_sync()

Returns: The requested value. Synchronously list conditions. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::Result< std::vector< TrackedCondition > > try_list_conditions_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to list conditions sync without throwing.

void get_condition_async(TrackedKey key, std::function< void(ua::Result< TrackedCondition >)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::Result< TrackedCondition >)>) - Completion callback that receives the operation result. Asynchronously get condition.

TrackedCondition get_condition_sync(TrackedKey key)

• key (TrackedKey) - The key.

Returns: The requested value. Synchronously get condition. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::Result< TrackedCondition > try_get_condition_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to get condition sync without throwing.

AlarmHandle handle(TrackedKey key) const noexcept

• key (TrackedKey) - Tracked condition and branch key.

Returns: The requested value. Mints an AlarmHandle for a known key (T30).

AlarmMetricsView alarm_metrics(ua::NodeId metricsObject) const noexcept

• metricsObject (ua::NodeId) - The metrics object.

Returns: The requested value. On-demand typed view over an AlarmMetricsType Object instance (CL-AC-026).

void refresh_async(std::function< void(ua::VoidResult)> callback) noexcept

• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Idempotent - a call while a window is open queues a follow-on; a call while a client-initiated refresh is already awaiting its RefreshEnd is REJECTED with Bad_RefreshInProgress (section 9.6.7 re-entrancy).

void refresh_sync()

Synchronously refresh.

ua::VoidResult try_refresh_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Attempts to refresh sync without throwing.

void acknowledge_async(TrackedKey key, std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously acknowledge.

void acknowledge_sync(TrackedKey key, std::optional< ua::LocalizedText > comment)

• key (TrackedKey) - The key.
• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously acknowledge. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_acknowledge_sync(TrackedKey key, std::optional< ua::LocalizedText > comment) noexcept

• key (TrackedKey) - The key.
• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to acknowledge sync without throwing.

void acknowledge_async(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• eventId (ua::ByteString) - Event identifier required by the condition method.
• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously acknowledge.

void acknowledge_sync(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment)

• key (TrackedKey) - The key.
• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously acknowledge. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_acknowledge_sync(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment) noexcept

• key (TrackedKey) - The key.
• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to acknowledge sync without throwing.

void confirm_async(TrackedKey key, std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously confirm.

void confirm_sync(TrackedKey key, std::optional< ua::LocalizedText > comment)

• key (TrackedKey) - The key.
• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously confirm. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_confirm_sync(TrackedKey key, std::optional< ua::LocalizedText > comment) noexcept

• key (TrackedKey) - The key.
• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to confirm sync without throwing.

void confirm_async(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• eventId (ua::ByteString) - Event identifier required by the condition method.
• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously confirm.

void confirm_sync(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment)

• key (TrackedKey) - The key.
• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously confirm. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_confirm_sync(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment) noexcept

• key (TrackedKey) - The key.
• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to confirm sync without throwing.

void add_comment_async(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• eventId (ua::ByteString) - Event identifier required by the condition method.
• comment (std::optional< ua::LocalizedText >) - Optional localized comment to attach to the operation.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously add comment.

void add_comment_sync(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment)

• key (TrackedKey) - The key.
• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment. Synchronously add comment. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_add_comment_sync(TrackedKey key, ua::ByteString eventId, std::optional< ua::LocalizedText > comment) noexcept

• key (TrackedKey) - The key.
• eventId (ua::ByteString) - The eventid.
• comment (std::optional< ua::LocalizedText >) - The comment.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to add comment sync without throwing.

void enable_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously enable.

void enable_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously enable. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_enable_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to enable sync without throwing.

void disable_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously disable.

void disable_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously disable. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_disable_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to disable sync without throwing.

void silence_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously silence.

void silence_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously silence. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_silence_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to silence sync without throwing.

void suppress_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously suppress.

void suppress_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously suppress. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_suppress_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to suppress sync without throwing.

void unsuppress_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously unsuppress.

void unsuppress_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously unsuppress. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_unsuppress_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to unsuppress sync without throwing.

void timed_shelve_async(TrackedKey key, ua::Duration shelvingTime, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• shelvingTime (ua::Duration) - The shelving time.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously timed shelve.

void timed_shelve_sync(TrackedKey key, ua::Duration shelvingTime)

• key (TrackedKey) - The key.
• shelvingTime (ua::Duration) - The shelvingtime. Synchronously timed shelve. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_timed_shelve_sync(TrackedKey key, ua::Duration shelvingTime) noexcept

• key (TrackedKey) - The key.
• shelvingTime (ua::Duration) - The shelvingtime.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to timed shelve sync without throwing.

void one_shot_shelve_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously one shot shelve.

void one_shot_shelve_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously one shot shelve. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_one_shot_shelve_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to one shot shelve sync without throwing.

void unshelve_async(TrackedKey key, std::function< void(ua::VoidResult)> callback) noexcept

• key (TrackedKey) - Tracked condition and branch key.
• callback (std::function< void(ua::VoidResult)>) - Completion callback that receives the operation result. Asynchronously unshelve.

void unshelve_sync(TrackedKey key)

• key (TrackedKey) - The key. Synchronously unshelve. Blocks the calling thread until the operation completes, so it must not be called from the executor thread that has to run the completion.

ua::VoidResult try_unshelve_sync(TrackedKey key) noexcept

• key (TrackedKey) - The key.

Returns: The operation result, including status and diagnostic detail on failure. Attempts to unshelve sync without throwing.

ua::client::BrowseOptions

The parameters of a BrowseCursor walk (client design section 7.5).

Defaults browse every forward reference of every node class, returning all result fields, at the server's default page size.

Public attributes

std::optional< ua::DateTime > viewTimestamp

Optional historical instant for a View browse. Mutually exclusive with viewVersion.

std::optional< std::uint32_t > viewVersion

Optional version for a View browse. Mutually exclusive with viewTimestamp.

ua::BrowseDirection direction

Which direction to follow references (Forward / Inverse / Both).

ua::NodeId referenceTypeId

Restrict to this reference type (and, per includeSubtypes, its subtypes).

bool includeSubtypes

When a referenceTypeId is given, also follow its subtypes.

std::uint32_t nodeClassMask

Restrict to these node classes (a bit mask of NodeClass values). 0 means "all node classes".

std::uint32_t resultMask

Which ReferenceDescription fields the server should populate (a bit mask). Defaults to all fields.

std::uint32_t requestedMaxReferencesPerNode

The maximum references the server returns per page (0 = server default).

ua::client::BrowseCursor

A forward iterator over the references from a start node (client design section 7.5).

BrowseCursor hides the BrowseResult / BrowseNext continuation-point dance behind a forward-iterator shape: next_async yields one Entry at a time, transparently issuing a BrowseNext when the current page is exhausted and the server held back a continuation point. The cursor idiom is unified with HistoryReadCursor (section 8.9): the same has_more predicate name, the same section 7.0 async / sync / try_sync triple on next_async, and the same close-on-destruct + explicit-close_async continuation-point release. Element granularity is per-Entry (vs the history cursor's per-page vector) - an intentional, kept difference.

Move-only: the moved-from cursor releases its continuation point on drop. Not directly constructible; obtained from TypedAccess::browse.

A BrowseCursor is a forward iterator: issue one next_async (or a *_sync variant) at a time and await its completion before issuing the next. Overlapping advances are rejected. The sync / try_sync variants block the calling thread; they MUST NOT be called from the Connection's executor thread.

Functions

BrowseCursor(BrowseCursor &&) noexcept=default

Returns or updates the browse cursor.

BrowseCursor & operator=(BrowseCursor &&) noexcept=default

Returns: A reference to this object. Supports value-handle comparison or assignment.

~BrowseCursor()

Posts a release-only BrowseNext (releaseContinuationPoints = true) to free the server's continuation point.

bool has_more() const noexcept

Returns: True iff more entries remain to yield - the current page has unconsumed entries, a continuation point is held, or the initial Browse has not yet been issued. False once the walk is fully drained.

void next_async(std::function< void(ua::Result< Entry >)> callback) noexcept

Fetches the next reference.

• callback (std::function< void(ua::Result< Entry >)>) - Receives the next Entry (or a bad Result) on the executor.

ua::Result< Entry > try_next_sync() noexcept

Returns: The operation result, including status and diagnostic detail on failure. Blocking try_* bridge over next_async; never throws. MUST NOT run on the executor thread.

Entry next_sync()

Returns: The requested value. Blocking bridge over next_async; throws UaException on a bad Result. MUST NOT run on the executor thread.

void close_async(std::function< void(ua::VoidResult)> callback) noexcept

Explicitly releases the continuation point now (a release-only BrowseNext).

• callback (std::function< void(ua::VoidResult)>) - Receives Good (or a bad Result) on the executor.

ua::VoidResult try_close_sync() noexcept

Returns: The requested value. Blocking try_* bridge over close_async; never throws. MUST NOT run on the executor thread.

void close_sync()

Blocking bridge over close_async; throws UaException on a bad Result.

ua::client::Client

Tier-1 root of the OPC UA Client SDK - the managed surface (client design section 7.1).

Composes a CoreClient by value and surfaces the managed entry points over it. Move-only handle; methods are safe to call from any thread and post their work to the executor supplied at create.

CoreClient, Connection, Discovery

Member types

ua::Result< Connection > ConnectResult

Result of a managed connect: the open Connection or an ErrorDetail.

std::function< void(ConnectResult)> ConnectCallback

Callback receiving the outcome of connect_async.

ua::Result< std::shared_ptr< PullCertificateManager > > PullCertificateManagerResult

The PullCertificateManager handle on success, or an ErrorDetail on failure (e.g.

std::function< void(PullCertificateManagerResult)> StartPullCertManagementCallback

Callback receiving the outcome of start_pull_cert_management_async.

std::function< void(ua::VoidResult)> ShutdownCallback

Callback receiving the outcome of shutdown_async.

ua::Result< Client > CreateResult

The created Client on success, or an ErrorDetail on failure.

Static functions

Client create(boost::asio::any_io_executor executor, CreateConfig config, std::shared_ptr< const ua::Crypto > crypto={}, std::shared_ptr< ua::CertificateStore > certStore={}, std::shared_ptr< ua::LogSink > logSink=nullptr, ua::LogLevel logLevel=ua::LogLevel::Info)

Creates a tier-1 Client with explicit configuration and optional crypto and certificate store.

• executor (boost::asio::any_io_executor) - Asio executor on which the client posts all of its work; must outlive the Client.
• config (CreateConfig) - Client creation configuration.
• crypto (std::shared_ptr< const ua::Crypto >) - Crypto provider to use; if null, a default provider is created.
• certStore (std::shared_ptr< ua::CertificateStore >) - Certificate store to use; if null, a default store is created.
• logSink (std::shared_ptr< ua::LogSink >) - Structured-log sink installed at construction, or null to disable logging.
• logLevel (ua::LogLevel) - Minimum level to emit (only meaningful when logSink is set).

Returns: A ready-to-use Client.

CreateResult try_create(boost::asio::any_io_executor executor, CreateConfig config, std::shared_ptr< const ua::Crypto > crypto={}, std::shared_ptr< ua::CertificateStore > certStore={}, std::shared_ptr< ua::LogSink > logSink=nullptr, ua::LogLevel logLevel=ua::LogLevel::Info) noexcept

Creates a tier-1 Client, returning a bad CreateResult instead of throwing on failure.

• executor (boost::asio::any_io_executor) - Asio executor on which the client posts all of its work; must outlive the Client.
• config (CreateConfig) - Client creation configuration.
• crypto (std::shared_ptr< const ua::Crypto >) - Crypto provider to use; if null, a default provider is created.
• certStore (std::shared_ptr< ua::CertificateStore >) - Certificate store to use; if null, a default store is created.
• logSink (std::shared_ptr< ua::LogSink >) - Structured-log sink installed at construction, or null to disable logging.
• logLevel (ua::LogLevel) - Minimum level to emit (only meaningful when logSink is set).

Returns: The created Client, or an ErrorDetail on failure. Never throws.

Functions

Client(Client &&) noexcept=default

Move-constructs from other, transferring ownership of the composed CoreClient.

Client & operator=(Client &&) noexcept=default

Move-assigns from other, transferring ownership of the composed CoreClient.

Returns: Reference to this Client.

~Client()

void connect_async(ConnectionConfig config, ConnectCallback callback) noexcept

Establishes a fully-managed Connection to a server endpoint (client design section 7.3).

• config (ConnectionConfig) - Endpoint, security, identity, session, and lifecycle-automation parameters.
• callback (ConnectCallback) - Receives the outcome: on success the open Connection; on failure an ErrorDetail naming the failing step. This overload never throws.

Connection connect_sync(ConnectionConfig config)

Establishes a managed Connection, blocking until the connect completes.

• config (ConnectionConfig) - Endpoint, security, identity, session, and lifecycle-automation parameters.

Returns: The open Connection.

ConnectResult try_connect_sync(ConnectionConfig config) noexcept

Establishes a managed Connection, blocking until the connect completes.

• config (ConnectionConfig) - Endpoint, security, identity, session, and lifecycle-automation parameters.

Returns: The open Connection, or an ErrorDetail on failure. Never throws.

void easy_connect_async(EasyConnectPolicy policy, ConnectCallback callback) noexcept

Establishes a managed Connection from a URL alone (client design section 7.3A).

• policy (EasyConnectPolicy) - Endpoint URL, identity, trust prompt, ranker, and the customize hook.
• callback (ConnectCallback) - Receives the open Connection, or an ErrorDetail whose source names the failing step (client.tier1.easy_connect.*). Never throws.

Connection easy_connect_sync(EasyConnectPolicy policy)

Discovery-driven managed connect, blocking until it completes.

• policy (EasyConnectPolicy) - Endpoint URL, identity, trust prompt, ranker, and the customize hook.

Returns: The open Connection.

ConnectResult try_easy_connect_sync(EasyConnectPolicy policy) noexcept

Discovery-driven managed connect, blocking until it completes.

• policy (EasyConnectPolicy) - Endpoint URL, identity, trust prompt, ranker, and the customize hook.

Returns: The open Connection, or an ErrorDetail on failure. Never throws.

Discovery discovery()

Returns the Client-level Discovery facade (client design section 7.6).

Returns: A Discovery value handle. Empty (all calls fail fast) if this Client has been shut down.

void set_mdns_transport(std::shared_ptr< ua::mdns::MdnsTransport > transport)

Installs an alternative mDNS transport used by Discovery::start_mdns_browse (client design section 8.12).

• transport (std::shared_ptr< ua::mdns::MdnsTransport >) - The mDNS transport to install, or null to restore the default.

void set_connection_observer(std::shared_ptr< ConnectionObserver > observer)

• observer (std::shared_ptr< ConnectionObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default connection / session lifecycle observer (section 7.8).

void set_subscription_observer(std::shared_ptr< SubscriptionObserver > observer)

• observer (std::shared_ptr< SubscriptionObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default Subscription / MonitoredItem lifecycle observer (section 7.8).

void set_security_observer(std::shared_ptr< SecurityObserver > observer)

• observer (std::shared_ptr< SecurityObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default certificate security observer (section 7.8).

void set_type_observer(std::shared_ptr< TypeObserver > observer)

• observer (std::shared_ptr< TypeObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default type-system observer (section 7.8).

void set_address_space_observer(std::shared_ptr< AddressSpaceObserver > observer)

• observer (std::shared_ptr< AddressSpaceObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default address-space model / semantic-change observer (section 7.8).

void set_server_state_observer(std::shared_ptr< ServerStateObserver > observer)

• observer (std::shared_ptr< ServerStateObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default server-state / progress / device-failure observer (section 7.8).

void set_alarm_observer(std::shared_ptr< AlarmObserver > observer)

• observer (std::shared_ptr< AlarmObserver >) - Observer to install; an empty pointer removes the observer. Sets the Client-level default Alarms & Conditions observer (section 7.8).

void start_pull_cert_management_async(PullCertManagementConfig config, StartPullCertManagementCallback callback) noexcept

Starts the per-Client Pull-Model certificate + trust-list refresh engine (client design section 8.1A).

• config (PullCertManagementConfig) - Pull-Model configuration (GDS endpoint, bootstrap + runtime trust stores, cadence).
• callback (StartPullCertManagementCallback) - Receives the manager handle, or an ErrorDetail on failure.

std::shared_ptr< PullCertificateManager > start_pull_cert_management(PullCertManagementConfig config)

Starts Pull-Model certificate management, blocking until the manager is constructed.

• config (PullCertManagementConfig) - Pull-Model configuration.

Returns: The shared PullCertificateManager handle.

PullCertificateManagerResult try_start_pull_cert_management_sync(PullCertManagementConfig config) noexcept

Starts Pull-Model certificate management, blocking until the manager is constructed.

• config (PullCertManagementConfig) - Pull-Model configuration.

Returns: The manager handle, or an ErrorDetail on failure. Never throws.

CoreClient & core() noexcept

Returns the composed tier-0 CoreClient (client design section 7.1).

Returns: Reference to the composed CoreClient; valid for this Client's lifetime. Never a shared_ptr - ownership stays with this Client.

const CoreClient & core() const noexcept

Returns the composed tier-0 CoreClient (client design section 7.1).

Returns: Reference to the composed CoreClient; valid for this Client's lifetime. Never a shared_ptr - ownership stays with this Client.

void shutdown_async(ShutdownCallback callback) noexcept

Initiates cascading client shutdown.

• callback (ShutdownCallback) - Receives a VoidResult once shutdown completes. Never throws.

void shutdown_sync()

Performs cascading shutdown, blocking until complete.

ua::VoidResult try_shutdown_sync() noexcept

Performs cascading shutdown, blocking until complete.

Returns: A VoidResult - success, or an ErrorDetail on failure. Never throws.

ua::client::CreateConfig

Value-based configuration bundle used when creating a Client.

Aggregates the three inputs CoreClient::create() needs: the application's identity, the shared application/stack configuration, and the client-specific defaults. It is passed by value so callers may edit it freely before construction; the client freezes its contents internally once created, and later mutation of the original struct has no effect.

CoreClient::create

Public attributes

::ua::ApplicationIdentity mIdentity

Identity advertised by the client (product URI, name, application type, build info).

::ua::ApplicationConfiguration mApplication

Shared application and stack configuration (security, timeouts, trust list, limits).

::ua::client::ClientConfiguration mClient

Client-specific defaults (service/session/channel timeouts, reverse-connect listeners).

ua::client::CombinedConfig

Complete configuration required to construct a client instance.

Bundles the three configuration inputs a client needs: the application identity advertised to servers, the shared application-wide configuration, and the client-only defaults.

Public attributes

::ua::ApplicationIdentity mIdentity

Application identity (product URI, application name, type) advertised to servers.

std::shared_ptr< const ::ua::ApplicationConfiguration > mApplication

Shared application-wide configuration (stack limits, trust list, etc.).

::ua::client::ClientConfiguration mClient

Client-only defaults (service/session timeouts, reverse-connect listeners, etc.).

ua::client::ClientConfiguration

Client-wide configuration defaults.

Each field supplies the default used when a per-call configuration struct leaves the corresponding option unset; an explicit per-call value always takes precedence. The struct is plain configuration data with no behaviour and no ownership of external resources - it is copied into the Client at construction time.

Public attributes

std::chrono::milliseconds mDefaultServiceTimeout

Default timeout applied to every service call, in milliseconds.

std::chrono::milliseconds mDefaultSessionTimeout

Default requested session timeout, in milliseconds.

std::chrono::milliseconds mDefaultChannelLifetime

Default requested secure channel lifetime, in milliseconds.

uint32_t mIncomingChunkQueueDepth

Maximum incoming message chunks buffered per channel awaiting decode before the client read-pauses the transport (stops re-arming the socket read until the queue drains below half this depth).

uint32_t mWriteQueueDepthPerConnection

Maximum buffers queued for transmission per outbound connection before async_write fails closed with Bad_TcpNotEnoughResources.

optional< uint32_t > mMaxInboundStringLength

Optional overrides for the client's inbound (server-response) decode size caps.

optional< uint32_t > mMaxInboundByteStringLength

Optional inbound byte-string size cap (bytes); nullopt keeps the bounded-floor default (16 MB).

optional< uint32_t > mMaxInboundArrayLength

Optional inbound array element-count cap; nullopt keeps the bounded-floor default (65535).

uint32_t mDefaultReturnDiagnostics

Default returnDiagnostics bitmask stamped on every request header.

ClientDiagnosticPolicy mDiagnostics

Client-wide defaults for diagnostic handling on direct tier-0 Session service calls.

ua::client::ClientDiagnosticPolicy

Per-Connection tunables for how the SDK surfaces decoded server diagnostics (client design section 7.10.4).

This is the single home for the diagnostics-related knobs so a Connection's diagnostic behaviour is configured in one place. It is attached to ConnectionConfig and decomposed into an immutable member at ua::client::detail::ConnectionImpl construction (read from any strand without synchronisation).

The defaults preserve the pre-policy behaviour exactly: the error-chain / advisory observer fires whenever the server attaches a DiagnosticInfo (which it only does when a request set returnDiagnostics != 0), and the decoded chain is depth-capped at 32.

This type grows as its requirements are wired. The WrapLevel field (CL-DIAG-015) is not yet present. It is added when their wiring lands, so a field present here is always enforced (no inert knobs).

Member types

WrapLevel (enum)

The wrap level.

• Minimal
• Standard
• Verbose

Public attributes

std::optional< std::uint32_t > requestedDiagnosticsMask

Overrides the Client-wide default on every request issued by this Connection.

bool wrapTier0

Opts direct tier-0 Session service results into one SDK context wrap.

WrapLevel wrapLevel

Controls SDK tier-boundary links and their context richness. Standard is the default.

bool emitOnErrorChainObserver

When true (the default), a decoded server diagnostic on a wire response fires the ua::client::ClientObserver error-chain hook (on_error_chain on a bad service result, on_advisory_diagnostic on a good one).

std::uint32_t maxChainDepth

Cap on the decoded ErrorDetail chain depth.

ua::client::DataChangeEvent

One decoded data-change notification delivered to a data-change monitor's callback (section 7.4).

The nodeId / attribute are pre-decoded from the pipeline's clientHandle table so the user never sees the wire handle.

Public attributes

MonitoredItemId itemId

The item id.

ua::NodeId nodeId

The node id.

ua::AttributeId attribute

The attribute.

ua::DataValue value

The value.

ua::client::AuditEventFields

Mandatory Part 5 AuditEventType properties decoded for an audit notification (CL-AUDIT-004).

Public attributes

ua::DateTime actionTimeStamp

The action time stamp.

bool status

The status.

ua::String serverId

The server id.

ua::String clientAuditEntryId

The client audit entry id.

ua::String clientUserId

The client user id.

ua::client::AuditSubtypeFields

Category-specific fields recognised from the standard AuditEventType subtree (CL-AUDIT-006).

Public attributes

AuditEventCategory category

The category.

std::optional< ua::StatusCode > statusCodeId

The status code id.

std::optional< ua::String > secureChannelId

The secure channel id.

std::optional< ua::NodeId > sessionId

The session id.

std::optional< ua::NodeId > methodId

The method id.

std::optional< ua::Variant > inputArguments

The input arguments.

ua::client::ProgressEventFields

Typed ProgressEventType properties (CL-EVT-006).

Context is always retained verbatim; Service events additionally expose the decoded RequestHeader.requestHandle.

Public attributes

ua::Variant context

The context.

std::uint16_t progress

The progress.

ProgressSourceKind sourceKind

The source kind.

std::optional< std::uint32_t > requestHandle

The request handle.

ua::client::EventNotification

One event notification delivered to an event consumer's callback (section 7.4 / section 8.13).

The decoded BaseEventType mandatory fields (CL-EVT-001) are surfaced as named members; fields carries every selected event-field value positionally in the order of the composite EventFilter.selectClauses (CL-EVT-002), with a null / unavailable field surfaced as nullopt (CL-MI-017). fieldPaths is the parallel BrowsePath metadata so callers can resolve a field by NAME (field / field_as, T22) instead of indexing positionally (robust under composite-filter widening).