lib/Desktop/AdNoctem.Substrate.Registry.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>AdNoctem.Substrate.Registry</name>
    </assembly>
    <members>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.DefaultUserHiveService">
            <summary>Hive lifecycle policy. Tests supply an isolated tool and mount/file probes.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.LegacyRegistryFileService">
            <summary>Publishes only successful nonempty output; failed runs preserve the previous destination.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.LegacyRegistryPath">
            <summary>Canonical registry identity independent of PowerShell providers.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.LegacyRegistryReader">
            <summary>Opens explicit registry views. A returned handle belongs to the caller.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.RegistryOperations">
            <summary>Legacy CRUD decisions, including comparison quirks and confirmation ordering.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.RegistrySettingAudit">
            <summary>Post-apply audit decisions used by existing configuration consumers.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.RegistryState">
            <summary>A raw, view-specific value snapshot. A null KeyExists denotes desired state.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.IRegistryStateStore">
            <summary>The narrow state boundary used for conflict, failure and race testing.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Compatibility.RegistryStore">
            <summary>Native registry access. All handles except those explicitly returned by LegacyRegistryReader are owned here.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Policies.RegistryPolicyFormatException">
            <summary>A malformed registry.pol stream, with its failure location retained for diagnosis.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Policies.RegistryPolicyCodec">
            <summary>PReg version 1 binary codec. Preserves record order and duplicates; never applies policy or invokes LGPO.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyCodec.Read(System.IO.Stream,System.Boolean,System.Threading.CancellationToken)">
            <remarks>The caller owns the readable, seekable stream. Reads from its current position to its end and returns only after complete validation.
            Cancellation is checked between records; synchronous stream reads cannot be interrupted. Raw reads can disable typed payload validation.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyCodec.Encode(System.Collections.Generic.IEnumerable{AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord},System.Threading.CancellationToken)">
            <summary>Validates and encodes the entire sequence before returning bytes. The caller owns the input sequence; payloads are copied into the result.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Policies.RegistryPolicyFileService">
            <summary>Reads and atomically publishes registry.pol files. Machine/User scope is supplied by the caller, never inferred or applied.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyFileService.WriteAsync(AdNoctem.Substrate.IO.FileSystemPath,System.Collections.Generic.IEnumerable{AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord},System.Boolean,System.Threading.CancellationToken)">
            <remarks>All records are validated before touching the destination. Cancellation before publication preserves it; the parent directory must exist.</remarks>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord">
            <summary>An immutable registry.pol record. Order, duplicate names and policy directives are significant; records never apply themselves.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord.#ctor(System.String,System.String,System.UInt32,System.Byte[])">
            <remarks>Payload is copied and may be opaque, including unknown native types. Decoding is an explicit operation.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord.GetRegistryPath(Microsoft.Win32.RegistryHive)">
            <summary>Projects a relative policy key through the shared registry path validator. The caller chooses the hive; no machine is accessed.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord.Decode">
            <summary>Returns a string, string array, UInt32, UInt64, opaque byte array, or null for a zero-byte payload. Arrays are independent copies.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord.TryGetRegistryValue(AdNoctem.Substrate.Registry.RegistryValue@)">
            <summary>Maps ordinary supported payloads to the existing registry value model. Unknown kinds, empty scalar payloads and invalid native strings are not coerced.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.Policies.RegistryPolicyRecord.FromDecoded(System.String,System.String,System.UInt32,System.Object)">
            <remarks>Decoded integer payloads must be unsigned whole numbers; use FromRegistryValue to preserve signed CLR registry integer bits.</remarks>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryChangeWatcher">
            <summary>Local Windows 8+ change signals. Notifications can coalesce and do not identify individual writes.</summary>
            <remarks>Arms immediately and rearms after a signal. A cancelled wait leaves the watcher usable; disposal closes the
            key/event and cancels a pending wait. Deletion invalidates the watched key: open a replacement key and create a new watcher.
            Remote notifications are unsupported. The Windows 8 requirement applies to thread-agnostic notifications, not ordinary CRUD.</remarks>
            <example><code>
            var registry = new RegistryManager();
            var settings = RegistryPath.Parse(@"HKCU\Software\ExampleApplication");
            using (var watcher = registry.Watch(settings, includeSubKeys: true))
            {
                await watcher.WaitForChangeAsync(cancellationToken);
                // Re-read the relevant settings; the signal does not identify individual writes.
            }
            </code></example>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryChangeWatcher.WaitForChangeAsync(System.Threading.CancellationToken)">
            <summary>One waiter at a time. Cancellation cancels the wait; Dispose releases the native registration.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryCommandRunner">
            <summary>Runs only the Windows registry utility, with independent argv quoting and drained output streams.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryFileService">
            <summary>Local registry file operations. Import is a mutation, not an atomic transaction or a scoped sandbox.</summary>
            <remarks>Uses the Windows system reg.exe matching the manager's view, with independently quoted arguments and captured output.
            Import can target multiple hives or remove keys; no subtree restriction is imposed. Export publishes through a sibling temporary
            file and preserves the previous destination on failure. Relative filesystem paths use the process working directory;
            pass absolute paths when stable resolution matters. The constructor accepts an optional execution timeout.
            Native failures retain output in RegistryCommandException. The library does not log, download executables or elevate.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryFileService.Export(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Boolean,System.Threading.CancellationToken)">
            <summary>Exports a local subtree to a registry text file; overwriting requires explicit permission.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryFileService.ExportAsync(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Boolean,System.Threading.CancellationToken)">
            <summary>Runs reg.exe export with a bounded timeout and the manager's resolved registry view.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryFileService.Import(System.String,System.Threading.CancellationToken)">
            <summary>Imports the entire file using the selected view. Cancellation/failure may leave partial registry changes.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryFileService.ImportAsync(System.String,System.Threading.CancellationToken)">
            <summary>Runs reg.exe import after validating the file. Cancellation or failure can leave partial registry changes.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryCommandException">
            <summary>A failed reg.exe operation with captured standard output, standard error, and any observed exit code.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryHiveService">
            <summary>Binary hive operations. Uses existing process authority; never prompts, elevates, or forces collection.</summary>
            <remarks>Binary hives are distinct from .reg text files. Operations require a local manager and use the system reg.exe for
            its selected view. Save publishes through a sibling temporary file, preserving the old destination on failure. Relative paths
            use the process working directory. Save/restore/load privileges must already be available to the caller.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.Save(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Boolean,System.Threading.CancellationToken)">
            <summary>Saves a local subtree to a binary hive file using reg.exe and the caller's existing authority.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.SaveAsync(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Boolean,System.Threading.CancellationToken)">
            <summary>Saves a binary hive without mounting it. Existing files require explicit overwrite.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.Restore(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Threading.CancellationToken)">
            <summary>Overwrites a key from a binary hive. Failure/cancellation does not roll back native writes.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.RestoreAsync(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Threading.CancellationToken)">
            <summary>Restores a binary hive using reg.exe; interruption does not guarantee that prior changes were undone.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.Mount(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Threading.CancellationToken)">
            <summary>Loads a new HKLM/HKU child and returns its owner. Once started, load finishes before returning ownership.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.MountAsync(AdNoctem.Substrate.Registry.RegistryPath,System.String,System.Threading.CancellationToken)">
            <summary>Loads a hive and transfers responsibility for unloading it to the returned lease.</summary>
            <remarks>The mount must be a missing immediate child of HKLM or HKU. Cancellation is checked before starting;
            once load starts it finishes before ownership is returned, even if cancellation is requested meanwhile.
            Close all child handles before disposing the lease. Unload failure throws and permits retry; no forced GC occurs.
            Caller-managed Unmount requires ownership and coordination against external replacement or unload races.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryHiveService.Unmount(AdNoctem.Substrate.Registry.RegistryPath)">
            <summary>Explicitly unloads a mount. Callers must own it and close all handles first.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryHiveLease">
            <summary>Owns one successful load. Dispose unloads it; a failed unload throws and can be retried.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryManager">
            <summary>Host-independent registry access for one machine and resolved view. No shared open handles.</summary>
            <remarks>
            <para>Reads distinguish missing data from access failures. Mutations use the caller's existing Windows authority.
            Multi-step operations are not transactions; inspect their results before assuming all requested changes completed.</para>
            <para>The view is fixed at construction. Remote access uses the caller's credentials and supports only HKLM and HKU;
            use an explicit SID for user data. Reachability, Remote Registry service configuration and permissions remain caller concerns.
            File/hive operations and notifications require a local manager.</para>
            <para>Value names are literal and case-insensitive. An empty name selects the default value; "(default)" is an ordinary name.
            String data comparisons remain case-sensitive. Async traversal offloads synchronous native calls and checks cancellation between
            operations; it cannot interrupt an individual registry call or remote RPC.</para>
            </remarks>
            <example><code>
            var registry = new RegistryManager(RegistryView.Registry64);
            var path = RegistryPath.Parse(@"HKCU\Software\ExampleApplication");
            registry.CreateKey(path);
            registry.SetValue(path, "Enabled", RegistryValue.DWord(1));
            registry.SetValue(path, "Cache", RegistryValue.ExpandString(@"%LOCALAPPDATA%\ExampleApplication"));
            if (registry.TryGetValue(path, "Cache", out var value))
            {
                var raw = value!.GetString();
                var expanded = value.GetString(expandEnvironmentVariables: true);
            }
            </code></example>
        </member>
        <member name="P:AdNoctem.Substrate.Registry.RegistryManager.View">
            <summary>The concrete view resolved at construction, including when the caller requested Default.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.#ctor(Microsoft.Win32.RegistryView,System.String)">
            <param name="view">Default resolves once to the calling process architecture.</param>
            <param name="machineName">Null for local access; a remote host name uses the caller's credentials.</param>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.OpenKey(AdNoctem.Substrate.Registry.RegistryPath,System.Boolean)">
            <summary>Returns a caller-owned handle, or null only when the key is missing. Access errors propagate.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.KeyExists(AdNoctem.Substrate.Registry.RegistryPath)">
            <summary>Tests whether a key can be opened. Access failures propagate instead of being reported as absence.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.CreateKey(AdNoctem.Substrate.Registry.RegistryPath)">
            <summary>Creates missing ancestors. Returns false if the key was already present when checked.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.DeleteKey(AdNoctem.Substrate.Registry.RegistryPath,System.Boolean)">
            <summary>Deletes a key. Recursion is opt-in; missing keys return false and access errors propagate.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.GetSubKeys(AdNoctem.Substrate.Registry.RegistryPath)">
            <summary>Returns immediate children; missing parents throw rather than appearing empty.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.GetValue(AdNoctem.Substrate.Registry.RegistryPath,System.String)">
            <summary>Raw read without environment expansion. Null means missing key or value, never access denied.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.TryGetValue(AdNoctem.Substrate.Registry.RegistryPath,System.String,AdNoctem.Substrate.Registry.RegistryValue@)">
            <summary>Returns false only for a missing key or value; unsupported data and access errors propagate.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.ValueExists(AdNoctem.Substrate.Registry.RegistryPath,System.String)">
            <summary>Checks for a named value without interpreting its data. An empty name denotes the default value.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.GetValueNames(AdNoctem.Substrate.Registry.RegistryPath)">
            <summary>Lists value names without reading their contents, for callers that must select an allowlist before collecting data.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.GetValues(AdNoctem.Substrate.Registry.RegistryPath)">
            <summary>Reads typed values in name order. A value disappearing during enumeration causes an error.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.SetValue(AdNoctem.Substrate.Registry.RegistryPath,System.String,AdNoctem.Substrate.Registry.RegistryValue,System.Boolean)">
            <summary>Writes explicit data and kind. Creating a missing key is opt-in.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.DeleteValue(AdNoctem.Substrate.Registry.RegistryPath,System.String)">
            <summary>Deletes one value and returns whether it was present; never deletes the containing key.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.EnumerateKeys(AdNoctem.Substrate.Registry.RegistryPath,System.Int32,System.Threading.CancellationToken)">
            <summary>Depth-first traversal including the root at depth zero. No snapshot isolation is implied.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.Search(AdNoctem.Substrate.Registry.RegistryPath,System.String,AdNoctem.Substrate.Registry.RegistrySearchOptions,System.Threading.CancellationToken)">
            <summary>Searches literal substrings and returns structured matches. Binary data is matched as hexadecimal.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.SearchAsync(AdNoctem.Substrate.Registry.RegistryPath,System.String,AdNoctem.Substrate.Registry.RegistrySearchOptions,System.Threading.CancellationToken)">
            <summary>Offloads synchronous Windows traversal; cancellation is checked between native operations.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.RenameKey(AdNoctem.Substrate.Registry.RegistryPath,System.String)">
            <summary>Renames within the same parent using the native registry operation. The target must not exist.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.Watch(AdNoctem.Substrate.Registry.RegistryPath,System.Boolean,AdNoctem.Substrate.Registry.RegistryChangeKinds)">
            <summary>Creates a caller-owned local registry watcher. Dispose it to release the notification handle.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.CopyKey(AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistryCopyMode,System.Threading.CancellationToken)">
            <summary>Copies data and empty keys. Destination permissions are inherited, not copied. Multi-step and non-atomic.</summary>
            <remarks>Overlapping trees are rejected. FailIfExists refuses an existing destination; Merge preserves unmentioned data;
            Replace removes unmentioned data inside the destination. Capture is not a point-in-time snapshot of a changing source.
            Cancellation during capture throws; cancellation during application returns completed writes without rollback.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.CopyKeyAsync(AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistryCopyMode,System.Threading.CancellationToken)">
            <summary>Copies a subtree on a worker thread, retaining completed changes if application fails or is cancelled.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.MoveKey(AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistryPath,System.Threading.CancellationToken)">
            <summary>Copies data to a missing destination, then removes an unchanged source. Permissions are not transferred.</summary>
            <remarks>Overlapping trees are rejected. Inspect both copy and source-removal results; a completed copy does not establish
            successful removal. Use RenameKey for an in-place rename. No retry silently overwrites newer state.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryManager.MoveKeyAsync(AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistryPath,System.Threading.CancellationToken)">
            <summary>Copies and then conditionally removes a subtree on a worker thread. Inspect both phases before treating the move as complete.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryMoveResult">
            <summary>Separate copy and removal outcomes; a completed copy does not imply that the source was removed.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryPath">
            <summary>A literal hive-relative key address. View and machine belong to the manager.</summary>
            <remarks>Accepts hive names such as HKCU or HKEY_CURRENT_USER followed by a backslash and subkey path.
            PowerShell provider syntax such as HKCU: is not supported. Wildcards and dot segments are literal key names;
            comparison is case-insensitive. This type does not select a registry view or resolve filesystem paths.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryPath.Combine(System.String)">
            <summary>Appends a relative literal path. Dot segments are registry names, not filesystem navigation.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistrySearchOptions">
            <summary>Selects registry names or data to search, case sensitivity, and maximum traversal depth.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistrySearchMatch">
            <summary>The key or named value that matched a literal search, with flags identifying the matching fields.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistrySecurityDescriptor">
            <summary>An immutable self-relative Windows security descriptor. Does not enable privileges or change identity.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistrySecurityService">
            <summary>Reads and writes selected registry security sections without enabling privileges or choosing an inheritance policy.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySecurityService.Write(AdNoctem.Substrate.Registry.RegistryPath,AdNoctem.Substrate.Registry.RegistrySecurityDescriptor,AdNoctem.Substrate.Registry.RegistrySecurityParts,System.Nullable{System.Boolean})">
            <summary>Writes only selected parts. Privileges and inheritance policy are the caller's responsibility.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryValueSnapshot">
            <summary>An immutable observation of one value, including distinct key and value absence.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryKeySnapshot">
            <summary>An immutable key observation. Security descriptors are managed separately.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryTreeSnapshot">
            <summary>A complete subtree observation, including empty keys. An empty Keys list records a missing root.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryTreeSnapshot.At(AdNoctem.Substrate.Registry.RegistryPath,Microsoft.Win32.RegistryView,System.String)">
            <summary>Explicitly maps data to another location. Does not read or write registry state.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryChange">
            <summary>One proposed registry mutation with observed before and desired after data.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryChangePlan">
            <summary>A reviewable, immutable plan. Its baseline is checked again when applied.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryApplyResult">
            <summary>Records completed writes even when a later operation fails or cancellation is requested.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistrySnapshotService">
            <summary>Capture and restoration without prompts. Checks narrow races but do not create registry transactions.</summary>
            <remarks>Snapshots retain raw values, empty keys, and resolved machine/view identity, but no security descriptors.
            Callers requiring a consistent capture must arrange quiescence. Read-only cancellation throws; apply cancellation returns
            a partial result. Completed writes are never rolled back automatically.</remarks>
            <example><code>
            var registry = new RegistryManager(Microsoft.Win32.RegistryView.Registry64);
            var settings = RegistryPath.Parse(@"HKCU\Software\ExampleApplication");
            var before = await registry.Snapshots.CaptureTreeAsync(settings, cancellationToken);
            // Perform application-controlled changes, then review the restoration plan.
            var plan = registry.Snapshots.PlanRestore(before, RegistryRestoreMode.Merge, cancellationToken);
            foreach (var change in plan.Changes)
            {
                // Present Path, Action, Name, Before and After as appropriate to the application.
            }
            var result = await registry.Snapshots.ApplyAsync(plan, cancellationToken);
            if (result.Status != RegistryApplyStatus.Completed)
            {
                // Inspect Completed, IncompleteChange and Error before deciding what to do next.
            }
            </code></example>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.CaptureValue(AdNoctem.Substrate.Registry.RegistryPath,System.String)">
            <summary>Records key absence separately from value absence, together with the manager's machine and registry view.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.CaptureTree(AdNoctem.Substrate.Registry.RegistryPath,System.Threading.CancellationToken)">
            <summary>Captures data and empty keys, not permissions. Concurrent changes can prevent a consistent observation.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.CaptureTreeAsync(AdNoctem.Substrate.Registry.RegistryPath,System.Threading.CancellationToken)">
            <summary>Captures a subtree on a worker thread, checking cancellation between native registry reads.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.PlanRestore(AdNoctem.Substrate.Registry.RegistryTreeSnapshot,AdNoctem.Substrate.Registry.RegistryRestoreMode,System.Threading.CancellationToken)">
            <summary>Reads current state and creates a reviewable restoration plan without applying it.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.Compare(AdNoctem.Substrate.Registry.RegistryTreeSnapshot,AdNoctem.Substrate.Registry.RegistryTreeSnapshot,AdNoctem.Substrate.Registry.RegistryRestoreMode)">
            <summary>Pure comparison. Merge preserves unmentioned keys/values; Replace removes them.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.Apply(AdNoctem.Substrate.Registry.RegistryChangePlan,System.Threading.CancellationToken,System.IProgress{AdNoctem.Substrate.Registry.RegistryChange})">
            <summary>Stops on the first conflict/failure. Cancellation returns a result retaining completed changes.</summary>
            <remarks>Plans apply only to their original machine/view. The entire baseline is compared before writing, then each change
            is checked immediately before and verified after its write. New data encountered during deletion causes a conflict rather
            than recursive pruning. A write is recorded before verification, so verification failure does not imply nothing changed.
            Progress reports verified changes; the supplied IProgress implementation determines how notifications are delivered.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.ApplyAsync(AdNoctem.Substrate.Registry.RegistryChangePlan,System.Threading.CancellationToken,System.IProgress{AdNoctem.Substrate.Registry.RegistryChange})">
            <summary>Applies a reviewed plan on a worker thread. Cancellation is recorded in the result with completed writes.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistrySnapshotService.RestoreValue(AdNoctem.Substrate.Registry.RegistryValueSnapshot,AdNoctem.Substrate.Registry.RegistryValueSnapshot,System.Threading.CancellationToken)">
            <summary>Restores only one value, preserving unrelated data. Expected state is optional; identity must match.</summary>
            <remarks>Restoring absence deletes only the value, retaining its key. Restoring a present value can recreate its parent;
            use a tree plan when each key creation needs a separate change record. Omitting expected state allows replacement of
            the currently observed value, with rechecks before writing but no atomic transaction.</remarks>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryValue">
            <summary>Immutable native value data. Integers preserve their signed CLR representation and raw bits.</summary>
            <remarks>String and ExpandString require string; DWord requires Int32; QWord requires Int64; Binary and None require byte[];
            MultiString requires string[]. Unsigned integer factory overloads preserve the raw bits. Arrays are copied on input and output.
            Strings cannot contain NUL. Multi-string elements must be nonempty, although an empty array is valid. Unsupported kinds and
            mismatched CLR data are rejected rather than coerced. ExpandString remains raw unless expansion is explicitly requested.</remarks>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryValue.GetData``1">
            <summary>Returns data as the requested CLR type, cloning arrays. Throws when the requested type does not match the native value.</summary>
        </member>
        <member name="M:AdNoctem.Substrate.Registry.RegistryValue.GetString(System.Boolean)">
            <summary>Expands using the calling process environment, including for values read from another machine.</summary>
        </member>
        <member name="T:AdNoctem.Substrate.Registry.RegistryValueEntry">
            <summary>A named value; an empty name denotes the key's default value.</summary>
        </member>
    </members>
</doc>