init

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups.md

@@ -0,0 +1,47 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetupsXMLClass.cs
+generated_at: "2026-04-16T02:45:54.754086+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "5f4c8b62435505ae"
+---
+
+# TestSetups
+
+## 1. Purpose  
+This module defines a serializable data contract class (`TestSetupsXMLClass`) used to represent a collection of test setup configurations in XML format. It serves as the root element container for deserializing or serializing test setup data—specifically, an array of `TestSetupXMLClass` objects—enabling structured persistence or exchange of test environment configurations (e.g., for test automation or test harness initialization). Its role is purely data-oriented: it provides the schema for XML I/O operations via `System.Xml.Serialization`, with no business logic or validation.
+
+## 2. Public Interface  
+- **`TestSetupsXMLClass`**  
+  - **Type**: `public class`  
+  - **Properties**:  
+    - `TestSetupXMLClass[] TestSetups { get; set; }`  
+      - **Behavior**: Gets or sets an array of `TestSetupXMLClass` instances. When serialized to XML, each element in the array becomes a `<TestSetup>` child element under the root `<TestSetups>` element. The property is nullable and may be `null` or an empty array.  
+
+- **`[XmlRootAttribute("TestSetups")]`**  
+  - **Type**: Class-level attribute (not a public member, but defines XML schema)  
+  - **Behavior**: Instructs the `XmlSerializer` to treat instances of `TestSetupsXMLClass` as the root element named `"TestSetups"` during XML serialization/deserialization.
+
+## 3. Invariants  
+- The `TestSetups` property must be an array of `TestSetupXMLClass` (or `null`) to conform to the XML schema defined by `[XmlElement("TestSetup")]`.  
+- The root XML element name is strictly `"TestSetups"` (case-sensitive) due to `[XmlRootAttribute("TestSetups")]`.  
+- Each item in the `TestSetups` array, if present, must serialize/deserialize as a `<TestSetup>` element (case-sensitive).  
+- No validation is performed on the contents of `TestSetups` (e.g., null elements, duplicates, or malformed `TestSetupXMLClass` instances are not prevented by this class).  
+
+## 4. Dependencies  
+- **Internal Dependencies**:  
+  - `DTS.Common.XMLUtils.TestSetupXMLClass` (referenced as `TestSetupXMLClass[]` but not defined in this file; assumed to be defined elsewhere in the same namespace).  
+- **Framework Dependencies**:  
+  - `System.Xml.Serialization` (for `[XmlRoot]` and `[XmlElement]` attributes).  
+- **External Dependencies**:  
+  - This module is consumed by code that uses `XmlSerializer` to read/write XML representations of test setups (e.g., test harness loaders, configuration managers). No other modules are *directly* visible as consumers in this file.  
+
+## 5. Gotchas  
+- **Null Safety**: The `TestSetups` property is not initialized by default. If deserialized from XML without any `<TestSetup>` elements, it will be `null` (not an empty array), which may cause `NullReferenceException` if callers assume it is always non-null. Callers must explicitly check for `null` or initialize the array before use.  
+- **Array Semantics**: The use of `[]` implies fixed-size array semantics; `XmlSerializer` will deserialize into an array (not a `List<T>`), and resizing requires reassignment.  
+- **No Validation**: The class does not enforce constraints on `TestSetupXMLClass` contents (e.g., required fields, uniqueness of IDs). Validation must be handled elsewhere.  
+- **Namespace Ambiguity**: The `[XmlRoot]` and `[XmlElement]` attributes do not specify a namespace; if the XML source uses a default or different namespace, deserialization may fail silently or produce unexpected results.  
+- **No Documentation on `TestSetupXMLClass`**: Behavior of individual test setups (e.g., required fields, serialization rules) is undefined here and depends on the implementation of `TestSetupXMLClass`.  
+
+None identified beyond the above.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup.md

@@ -0,0 +1,63 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/TestSetupXMLClass.cs
+generated_at: "2026-04-16T02:46:10.278947+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "cdc9e48282466860"
+---
+
+# TestSetup
+
+## 1. Purpose  
+This module defines the `TestSetupXMLClass`, a data contract class used for serializing and deserializing test setup configurations to and from XML. It serves as the root object model for representing structured test setup data—including identifiers, DAS (Data Acquisition System) lists, groups, fields, hardware includes, level triggers, and metadata—in a standardized XML format compatible with the .NET `XmlSerializer`. Its role is to bridge in-memory test setup objects and persistent XML representations, enabling configuration storage, exchange, and versioning within the DTS (Design & Test System) ecosystem.
+
+## 2. Public Interface  
+
+- **`public class TestSetupXMLClass`**  
+  A serializable class representing a test setup configuration. All properties are public and auto-implemented; the class is intended for use with `XmlSerializer`.
+
+  - **`public string Id { get; set; }`**  
+    Gets or sets the unique identifier for this test setup instance. Serialized as a top-level XML element named `<Id>`.
+
+  - **`[XmlElement("DASList")] public List<DASListXMLClass> DASList { get; set; }`**  
+    Gets or sets a list of DAS configuration entries. Serialized as zero or more `<DASList>` elements (due to `[XmlElement]`, not `<DASList>` wrapper). Type `DASListXMLClass` is referenced but not defined in this file.
+
+  - **`[XmlElement("Groups")] public List<GroupsXMLClass> Groups { get; set; }`**  
+    Gets or sets a list of group definitions. Serialized as zero or more `<Groups>` elements. Type `GroupsXMLClass` is referenced but not defined in this file.
+
+  - **`[XmlElement("Fields")] public FieldsXMLClass Fields { get; set; }`**  
+    Gets or sets a single `Fields` configuration object. Serialized as a single `<Fields>` element. Type `FieldsXMLClass` is referenced but not defined in this file.
+
+  - **`public string HardwareIncludes { get; set; }`**  
+    Gets or sets a string describing hardware components included in the test setup. Serialized as a top-level `<HardwareIncludes>` element.
+
+  - **`[XmlElement("LevelTriggers")] public LevelTriggersXMLClass LevelTriggers { get; set; }`**  
+    Gets or sets a single `LevelTriggers` configuration object. Serialized as a single `<LevelTriggers>` element. Type `LevelTriggersXMLClass` is referenced but not defined in this file.
+
+  - **`[XmlElement("MetaDatas")] public MetaDatasXMLClass MetaDatas { get; set; }`**  
+    Gets or sets a single `MetaDatas` configuration object. Serialized as a single `<MetaDatas>` element. Type `MetaDatasXMLClass` is referenced but not defined in this file.
+
+> **Note**: All nested types (`DASListXMLClass`, `GroupsXMLClass`, `FieldsXMLClass`, `LevelTriggersXMLClass`, `MetaDatasXMLClass`) are referenced but not defined in this file; their structure must be defined elsewhere.
+
+## 3. Invariants  
+- **`Id` must be non-null and non-empty** for valid test setup instances (implied by semantic usage, though not enforced in code).  
+- **`DASList`, `Groups`, `LevelTriggers`, `MetaDatas`, and `Fields` may be `null` or empty lists**; `XmlSerializer` handles `null` reference properties by omitting the element, and empty lists result in no child elements (for `[XmlElement]`-decorated collections).  
+- **XML element names are strictly controlled via `[XmlElement]` attributes**; e.g., `DASList` property serializes to `<DASList>`, not `<DASListXMLClass>` or `<DAS_List>`.  
+- **No validation or business logic is enforced in this class**; it is a pure data container.
+
+## 4. Dependencies  
+- **Depends on**:  
+  - `System.Xml.Serialization` (for `[XmlElement]` attribute and `XmlSerializer` compatibility).  
+  - Types `DASListXMLClass`, `GroupsXMLClass`, `FieldsXMLClass`, `LevelTriggersXMLClass`, and `MetaDatasXMLClass` (referenced but not defined here—must be defined in other files in the same or referenced assemblies).  
+- **Used by**:  
+  - XML serialization/deserialization logic (e.g., `XmlSerializer.Serialize`/`Deserialize` calls elsewhere in the codebase).  
+  - Likely consumed by modules handling test setup persistence, export/import, or configuration management (e.g., UI layers or service endpoints that read/write XML test setup files).  
+- **No internal dependencies beyond core .NET types** (`string`, `List<T>`, `object`).
+
+## 5. Gotchas  
+- **`[XmlElement]` vs. `[XmlArray]` behavior**: The use of `[XmlElement("DASList")]` on a `List<T>` property causes each item to serialize as a separate `<DASList>` element *without* a container element. If a `<DASList><item/><item/></DASList>` structure was intended, `[XmlArray("DASList")]` and `[XmlArrayItem]` would be required instead. This is likely intentional but non-obvious.  
+- **Missing null-safety**: The class does not initialize collections (e.g., `DASList = new();`). Consumers must handle `null` collections explicitly or risk `NullReferenceException` during enumeration or serialization.  
+- **No versioning or schema evolution support**: The class lacks attributes like `[XmlIgnore]` for optional fields or `[XmlAttribute]` for metadata—suggesting rigid XML contract expectations. Adding new fields may break backward compatibility.  
+- **No documentation for nested types**: Since `DASListXMLClass`, `GroupsXMLClass`, etc., are not defined here, their structure and semantics are unknown from this source alone.  
+- **`HardwareIncludes` is a plain string**: Its format (e.g., comma-separated IDs, JSON, or free text) is unspecified and must be inferred from usage elsewhere.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/DASList.md

@@ -0,0 +1,37 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/DASList/DASListXMLClass.cs
+generated_at: "2026-04-16T02:46:18.529804+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "0698eade6a1a94d9"
+---
+
+# DASList
+
+### 1. Purpose  
+This module defines a serializable data structure (`DASListXMLClass`) used to represent a collection of DAS (Data Acquisition System) hardware configurations in XML format. It serves as a top-level container for serializing/deserializing lists of `DASHardwareXMLClass` objects during test setup export/import operations, enabling persistence and interoperability of hardware configuration data.
+
+### 2. Public Interface  
+- **`DASListXMLClass`**  
+  - **`[XmlElement("DASList")] public List<DASHardwareXMLClass> DASList { get; set; }`**  
+    A public property that holds a list of `DASHardwareXMLClass` instances. When serialized using `XmlSerializer`, the list is wrapped in an XML element named `<DASList>`. The property supports both reading and writing; the list may be `null` if not initialized.
+
+### 3. Invariants  
+- The `DASList` property may be `null` or an empty list; no invariant enforces non-nullability or non-emptiness.  
+- The XML element name for the list is strictly `"DASList"` (case-sensitive), as enforced by the `[XmlElement("DASList")]` attribute.  
+- Each item in the `DASList` must be an instance of `DASHardwareXMLClass` (or a derived type, if supported by the serializer), but no further validation is performed by this class itself.
+
+### 4. Dependencies  
+- **Depends on:**  
+  - `System.Xml.Serialization` (for `XmlElementAttribute` and `XmlSerializer` usage)  
+  - `DASHardwareXMLClass` (referenced as the generic type argument; assumed to be defined elsewhere in the codebase, likely in the same namespace or a related module)  
+- **Used by:**  
+  - XML serialization/deserialization logic (e.g., `XmlSerializer.Serialize`/`Deserialize`) for test setup configurations.  
+  - Likely consumed by higher-level classes handling test setup export/import (e.g., classes in `DTS.Common.XMLUtils` or related test framework modules), though not explicitly stated in this file.
+
+### 5. Gotchas  
+- **No null-safety for `DASList`**: If `DASList` is `null` at serialization time, the `<DASList>` element will be omitted from the XML output (default `XmlSerializer` behavior for nullable collections). Initialization (e.g., `new DASListXMLClass { DASList = new List<DASHardwareXMLClass>() }`) is required to ensure the element appears even when empty.  
+- **No explicit validation**: The class does not enforce constraints on the contents of `DASList` (e.g., uniqueness, non-null items). Invalid `DASHardwareXMLClass` instances may serialize but cause downstream errors.  
+- **Assumed dependency**: `DASHardwareXMLClass` is referenced but not defined here; its structure and serialization behavior (e.g., properties, attributes) are not documented in this file and must be verified separately.  
+- **No versioning or schema metadata**: The class lacks attributes like `XmlRoot` or `XmlType`, implying it is intended to be used as a nested element (not a root element) in a larger XML document.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/DASList/DASHardware.md

@@ -0,0 +1,47 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/DASList/DASHardware/DASHardwareXMLClass.cs
+generated_at: "2026-04-16T02:46:42.970780+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "a779f8dd58b270c4"
+---
+
+# DASHardware
+
+## 1. Purpose  
+This module defines a data transfer object (`DASHardwareXMLClass`) used for serializing and deserializing hardware configuration data related to Data Acquisition System (DAS) hardware components in XML format. It exists to enable structured persistence and exchange of key hardware attributes—such as serial number, sampling rate, and clock master status—between components of the DTS system and external tools or storage layers, leveraging .NET’s `XmlSerializer`.
+
+## 2. Public Interface  
+The class exposes only public properties; no methods or constructors are defined in the source.
+
+- **`public string SerialNumber { get; set; }`**  
+  Stores the hardware’s serial number as a string. Intended to uniquely identify the physical device.
+
+- **`public string SamplesPerSecond { get; set; }`**  
+  Stores the hardware’s sampling rate (in Hz) as a string. *Note: Despite the name implying a numeric value, it is stored as a string, not a numeric type.*
+
+- **`public string IsClockMaster { get; set; }`**  
+  Stores a boolean-like flag indicating whether this hardware acts as the clock master for the system, represented as a string (e.g., `"True"`/`"False"` or `"1"`/`"0"`). *Note: Stored as string, not `bool`.*
+
+## 3. Invariants  
+- All properties are nullable reference types (no explicit nullability annotations in source), and no validation or initialization logic is present.  
+- No constraints are enforced on the format or content of `SerialNumber`, `SamplesPerSecond`, or `IsClockMaster`.  
+- The class is designed for XML serialization/deserialization via `XmlSerializer`; property names and casing must match XML element names exactly (case-sensitive).  
+- No ordering guarantees are specified for XML serialization (depends on `XmlSerializer` default behavior, which typically follows declaration order).
+
+## 4. Dependencies  
+- **Depends on**:  
+  - `System.Xml.Serialization` (for `XmlSerializer` compatibility)  
+  - Standard .NET libraries (`System`, `System.Collections.Generic`, etc.)  
+- **Used by**:  
+  - Other modules in `DTS.Common.XMLUtils` (inferred from namespace) that serialize/deserialize DAS hardware configurations.  
+  - Likely consumed by XML export/import utilities (e.g., `TestSetupExportXML`—suggested by file path).  
+- **No external project or third-party dependencies** are evident from the source.
+
+## 5. Gotchas  
+- **String-based numeric/boolean fields**: `SamplesPerSecond` and `IsClockMaster` are stored as `string` instead of `double`/`int` and `bool`, respectively. This requires callers to manually parse and validate values, risking runtime errors if format assumptions (e.g., `"1000.0"`, `"True"`) are violated.  
+- **No null-safety or default values**: Uninitialized properties will serialize as empty elements or omit fields (depending on `XmlSerializer` settings), potentially causing downstream deserialization ambiguity.  
+- **No validation logic**: Invalid or malformed values (e.g., non-numeric `SamplesPerSecond`) are not caught at construction or serialization time.  
+- **Case sensitivity**: XML element names will be `SerialNumber`, `SamplesPerSecond`, and `IsClockMaster` exactly; mismatches in casing (e.g., `serialnumber`) will cause deserialization failures.  
+- **Historical quirk**: The naming `DASHardwareXMLClass` suggests a legacy pattern where XML DTOs were suffixed `*XMLClass`; modern design might favor `*Dto` or `*Model`.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Fields.md

@@ -0,0 +1,124 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Fields/FieldsXMLClass.cs
+generated_at: "2026-04-16T02:46:57.774050+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "5e86a340c9482f6a"
+---
+
+# Fields
+
+## 1. Purpose  
+`FieldsXMLClass` is a data container class used to serialize and deserialize test setup configuration metadata to/from XML format within the DTS Common Core XML utilities module. It acts as a flat, string-typed representation of user-configurable test setup parameters—such as trigger behavior, recording settings, export options, diagnostics, and metadata fields—intended for persistence and interchange, likely as part of test setup export/import workflows. The class does not contain business logic; it solely encapsulates named fields whose values are stored as strings, presumably parsed or formatted elsewhere in the codebase.
+
+## 2. Public Interface  
+All members are public read-write properties of type `string`. No methods, constructors, or nested types are defined in this class.
+
+| Property Name | Type | Description |
+|---------------|------|-------------|
+| `SetupName` | `string` | Name of the test setup. |
+| `SetupDescription` | `string` | Human-readable description of the test setup. |
+| `AutomaticTestProgression` | `string` | Indicates whether automatic progression between test steps is enabled. |
+| `AutomaticProgressionDelayMS` | `string` | Delay (in milliseconds) before automatic progression. |
+| `InvertTrigger` | `string` | Whether the trigger signal is inverted. |
+| `InvertStart` | `string` | Whether the start signal is inverted. |
+| `IgnoreShortedStart` | `string` | Whether to ignore shorted start conditions. |
+| `IgnoreShortedTrigger` | `string` | Whether to ignore shorted trigger conditions. |
+| `ViewDiagnostics` | `string` | Whether diagnostics are displayed during the test. |
+| `VerifyChannels` | `string` | Whether channel verification is enabled. |
+| `AutoVerifyChannels` | `string` | Whether channel verification is performed automatically. |
+| `VerifyChannelsDelayMS` | `string` | Delay (in milliseconds) before channel verification. |
+| `RecordingMode` | `string` | Mode of data recording (e.g., continuous, event-based). |
+| `SamplesPerSecond` | `string` | Sampling rate (Hz) for data acquisition. |
+| `PreTriggerSeconds` | `string` | Duration (in seconds) of data recorded before trigger. |
+| `PostTriggerSeconds` | `string` | Duration (in seconds) of data recorded after trigger. |
+| `NumberOfEvents` | `string` | Number of events to record. |
+| `WakeUpMotionTimeout` | `string` | Timeout (in seconds) for motion-based wake-up. |
+| `ScheduledStartDateTime` | `string` | Date/time string for scheduled test start. |
+| `IntervalBetweenEventStartsMinutes` | `string` | Interval (in minutes) between consecutive event starts. |
+| `StartWithEvent` | `string` | Whether the test starts automatically with an event. |
+| `WakeUpWithMotion` | `string` | Whether motion triggers test wake-up. |
+| `StrictDiagnostics` | `string` | Whether strict diagnostics mode is enabled. |
+| `RequireConfirmationOnErrors` | `string` | Whether user confirmation is required before proceeding after errors. |
+| `ROIDownload` | `string` | Whether Regions of Interest (ROI) download is enabled. |
+| `ViewROIDownload` | `string` | Whether ROI download view is enabled. |
+| `DownloadAll` | `string` | Whether all data should be downloaded. |
+| `ViewRealtime` | `string` | Whether real-time data viewing is enabled. |
+| `RealtimePlotCount` | `string` | Number of data points/plots to display in real-time view. |
+| `ROIStart` | `string` | Start index or time for ROI. |
+| `ROIEnd` | `string` | End index or time for ROI. |
+| `ViewDownloadAll` | `string` | Whether the “download all” view is enabled. |
+| `Export` | `string` | Whether export is enabled. |
+| `ExportFormat` | `string` | Format specifier for exported data (e.g., CSV, TDMS). |
+| `LabDetails` | `string` | Laboratory-related metadata (likely serialized JSON or free text). |
+| `UseLabDetails` | `string` | Whether lab details are used/included. |
+| `CustomerDetails` | `string` | Customer-related metadata. |
+| `UseCustomerDetails` | `string` | Whether customer details are used/included. |
+| `AllowMissingSensors` | `string` | Whether test proceeds if sensors are missing. |
+| `AllowSensorIdToBlankChannel` | `string` | Whether a blank channel can be assigned a sensor ID. |
+| `ExcitationWarmupTimeMS` | `string` | Warm-up time (in milliseconds) for excitation circuitry. |
+| `LocalOnly` | `string` | Whether test runs in local-only mode (no network). |
+| `LastModified` | `string` | Timestamp of last modification (likely ISO 8601 or similar). |
+| `LastModifiedBy` | `string` | User identifier who last modified the setup. |
+| `TurnOffExcitation` | `string` | Whether excitation is turned off after test. |
+| `TriggerCheckRealtime` | `string` | Whether trigger checks occur in real time. |
+| `TriggerCheckStep` | `string` | Whether trigger checks occur at specific steps. |
+| `PostTestDiagnostics` | `string` | Whether diagnostics run after test completion. |
+| `ExportFolder` | `string` | Path to folder for exported files. |
+| `DownloadFolder` | `string` | Path to folder for downloaded data. |
+| `CommonStatusLine` | `string` | Shared status message or template. |
+| `SameAsDownloadFolder` | `string` | Whether export folder is the same as download folder. |
+| `UploadData` | `string` | Whether uploaded data is enabled. |
+| `UploadDataFolder` | `string` | Path to folder for uploaded data. |
+| `UploadExportsOnly` | `string` | Whether only exported files are uploaded. |
+| `Settings` | `string` | Generic settings string (likely serialized key-value pairs). |
+| `WarnOnBatteryFail` | `string` | Whether to warn on battery failure. |
+| `Dirty` | `string` | Whether the setup has unsaved changes (boolean as string). |
+| `Complete` | `string` | Whether the test setup is complete (boolean as string). |
+| `ErrorMessage` | `string` | Last recorded error message. |
+| `TestEngineerDetails` | `string` | Test engineer’s metadata (e.g., name, ID). |
+| `UseTestEngineerDetails` | `string` | Whether test engineer details are used. |
+| `UserTags` | `string` | User-defined tags (likely comma-separated or JSON). |
+| `DoAutoArm` | `string` | Whether auto-arm is enabled. |
+| `DoEnableRepeat` | `string` | Whether repeat mode is enabled. |
+| `DoStreaming` | `string` | Whether streaming mode is enabled. |
+| `CheckoutMode` | `string` | Whether checkout mode is active. |
+| `QuitTestWithoutWarning` | `string` | Whether test can be quit without warning. |
+| `SuppressMissingSensorsWarning` | `string` | Whether missing-sensor warnings are suppressed. |
+| `ISFFile` | `string` | Path or identifier for ISF (Instrument Standard Format) file. |
+| `NotAllChannelsRealTime` | `string` | Whether not all channels support real-time operation. |
+| `NotAllChannelsViewer` | `string` | Whether not all channels are visible in viewer. |
+| `CalibrationBehavior` | `string` | Calibration behavior mode (e.g., auto, manual, none). |
+| `ClockSyncProfileMaster` | `string` | Clock synchronization profile for master devices. |
+| `ClockSyncProfileSlave` | `string` | Clock synchronization profile for slave devices. |
+| `ExtraProperties` | `string` | Additional custom properties (likely serialized). |
+| `MeasureSquibResistancesStep` | `string` | Whether squib resistance measurement occurs at a specific step. |
+| `TestSetupUniqueId` | `string` | Unique identifier for the test setup instance. |
+
+## 3. Invariants  
+- All properties are nullable and may contain empty strings (`""`).  
+- No validation is performed within this class; invalid values (e.g., non-numeric strings for numeric fields like `SamplesPerSecond`) are not prevented by this type.  
+- The class assumes string-based serialization/deserialization semantics—likely via XML serialization attributes (not shown here) or manual mapping.  
+- No ordering or interdependency guarantees exist among properties; e.g., `ROIStart` and `ROIEnd` are not validated for consistency (e.g., `ROIStart ≤ ROIEnd`).  
+- Boolean-like fields (e.g., `Dirty`, `Complete`, `AllowMissingSensors`) are stored as strings (e.g., `"True"`/`"False"`, `"1"`/`"0"`, or `"Yes"`/`"No"`), but the actual expected format is not defined in this file.
+
+## 4. Dependencies  
+- **Internal dependencies**:  
+  - Depends on `System`, `System.Collections.Generic`, `System.Linq`, `System.Text`, and `System.Threading.Tasks` (standard .NET libraries).  
+  - Belongs to the `DTS.Common.XMLUtils` namespace, implying integration with other XML serialization utilities (e.g., classes handling XML read/write).  
+- **External dependencies**:  
+  - No external NuGet or third-party dependencies are evident from this file alone.  
+- **Consumers**:  
+  - Likely consumed by XML serialization/deserialization logic (e.g., methods in surrounding `XMLUtils` namespace that map XML elements to/from `FieldsXMLClass` instances).  
+  - May be used by test engine or UI layers that read/write test setup configurations.  
+  - The commented-out `RegionsOfInterestXMLClass` property suggests a related class exists or was planned, indicating potential coupling with ROI-specific types.
+
+## 5. Gotchas  
+- **All values are strings**: Critical numeric, boolean, or datetime fields (e.g., `SamplesPerSecond`, `Dirty`, `LastModified`) are stored as `string`, requiring consumers to parse and validate them. Misinterpretation of format (e.g., culture-specific number formats, ambiguous date strings) is a likely source of bugs.  
+- **No validation or normalization**: The class does not enforce constraints (e.g., `SamplesPerSecond > 0`, `PreTriggerSeconds ≥ 0`, `ExportFormat ∈ {"CSV", "TDMS"}`). Validation must occur elsewhere.  
+- **Commented-out property**: The `RegionsOfInterest` property is commented out, suggesting incomplete or deprecated ROI handling. Consumers may need to infer ROI data from `ROIStart`/`ROIEnd` or other fields.  
+- **Ambiguous boolean representation**: Fields like `Dirty`, `Complete`, and `AllowMissingSensors` likely represent booleans, but the expected string values (e.g., `"true"` vs `"True"` vs `"1"`) are not documented here.  
+- **No XML attributes**: The source file lacks `[XmlElement]`, `[XmlAttribute]`, or `[Serializable]` attributes, implying XML mapping is handled externally (e.g., via reflection conventions or manual mapping). This makes serialization behavior dependent on external code.  
+- **No constructor or initialization logic**: Default values must be set by consumers; uninitialized properties will be `null`.  
+- **None identified from source alone.**

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups.md

@@ -0,0 +1,37 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/GroupsXMLClass.cs
+generated_at: "2026-04-16T02:46:28.277836+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "94927ff50438ae78"
+---
+
+# Groups
+
+## 1. Purpose  
+This module defines a serializable data structure (`GroupsXMLClass`) used to represent a collection of test group configurations in XML format, specifically for export during test setup operations. It serves as the root container object in XML serialization/deserialization workflows within the `DTS.Common.XMLUtils` namespace, enabling structured persistence and exchange of hierarchical test group data.
+
+## 2. Public Interface  
+- **`GroupsXMLClass`**  
+  - **`[XmlElement("Group")] public List<GroupXMLClass> Group { get; set; }`**  
+    A list of `GroupXMLClass` instances representing individual test groups. During XML serialization, each element in this list is serialized as a `<Group>` element (due to the `[XmlElement("Group")]` attribute). The property is nullable and may be `null` or an empty list.
+
+## 3. Invariants  
+- The `Group` property must be a `List<GroupXMLClass>` (or `null`)—no other collection types are supported by the current implementation.  
+- XML serialization will produce one `<Group>` element per item in the `Group` list; no additional wrapper elements are used.  
+- The class itself has no validation logic; it does not enforce non-nullability, ordering, or uniqueness of `Group` entries.  
+- The class is designed for use with `System.Xml.Serialization.XmlSerializer`; behavior with other serializers (e.g., `System.Text.Json`) is undefined.
+
+## 4. Dependencies  
+- **Internal dependency**: Relies on `GroupXMLClass` (referenced in the `Group` property type), which is presumably defined elsewhere in the same namespace (`DTS.Common.XMLUtils`).  
+- **External dependencies**:  
+  - `System.Collections.Generic` (`List<T>`)  
+  - `System.Xml.Serialization` (`XmlElementAttribute`, `XmlSerializer`)  
+- **Consumers**: Likely consumed by XML export/import utilities in the test setup module (e.g., classes responsible for serializing/deserializing test configurations to/from XML files). No explicit usage is visible in this file.
+
+## 5. Gotchas  
+- The property name `Group` (singular) is used for a list—this may be confusing, as it implies a single item, but the `[XmlElement("Group")]` attribute indicates plural semantics (multiple `<Group>` elements). This naming convention is common in XML serialization but can cause misunderstandings.  
+- No constructor initializes the `Group` list; callers must explicitly instantiate it (e.g., `new GroupsXMLClass { Group = new List<GroupXMLClass>() }`) to avoid `NullReferenceException` during serialization.  
+- The class has no methods beyond the auto-implemented property; all logic (e.g., validation, transformation) must reside in external consumers.  
+- No documentation comments are present in the source, so behavioral assumptions (e.g., expected child element order, required fields in `GroupXMLClass`) cannot be verified here.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group.md

@@ -0,0 +1,76 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/GroupXMLClass.cs
+generated_at: "2026-04-16T02:47:04.917759+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "78f70884084c66ba"
+---
+
+# Group
+
+## 1. Purpose  
+`GroupXMLClass` is a data contract class used for XML serialization/deserialization of test group metadata within the DTS (Design & Test System) framework. It represents a logical grouping of test hardware and channels in a test setup, enabling structured persistence and exchange of test configuration data via XML. This class serves as the canonical in-memory representation of a `<Group>` element during export/import operations for test setups.
+
+## 2. Public Interface  
+
+- **`GroupXMLClass()`**  
+  Parameterless constructor. Initializes `HardwareList` to a new `HardwareListXMLClass` instance and `Channel` to a new empty `List<ChannelXMLClass>`. Required for XML serialization via `XmlSerializer`.
+
+- **`string Name { get; set; }`**  
+  Internal identifier for the group. Typically a non-empty, system-unique string.
+
+- **`string DisplayName { get; set; }`**  
+  Human-readable label for the group, used in UI or reports.
+
+- **`string Description { get; set; }`**  
+  Optional free-text description of the group’s purpose or contents.
+
+- **`string TestSetupName { get; set; }`**  
+  Name of the parent test setup to which this group belongs.
+
+- **`string DisplayOrder { get; set; }`**  
+  String-based ordering hint (e.g., `"1"`, `"002"`) indicating display sequence relative to other groups. *Not* enforced as numeric; interpretation is caller-dependent.
+
+- **`string Position { get; set; }`**  
+  Physical or logical position indicator (e.g., `"A"`, `"1.2"`). Semantics are context-specific and not validated by this class.
+
+- **`string TestObjectType { get; set; }`**  
+  Type classification of the test object associated with this group (e.g., `"DUT"`, `"Fixture"`). Value is unvalidated.
+
+- **`string Id { get; set; }`**  
+  Unique identifier for the group instance (e.g., GUID or UUID string). Intended for cross-reference.
+
+- **`string StaticGroupId { get; set; }`**  
+  Identifier for a static template or base group from which this group may be derived. May be `null` or empty for non-template groups.
+
+- **`HardwareListXMLClass HardwareList { get; set; }`**  
+  Nested object containing hardware-related configuration (e.g., devices, connections). Serialized as `<HardwareList>` element.
+
+- **`List<ChannelXMLClass> Channel { get; set; }`**  
+  Ordered list of channel definitions associated with this group. Serialized as repeated `<Channel>` elements.
+
+## 3. Invariants  
+- `HardwareList` is **never null** after construction (initialized in constructor).  
+- `Channel` is **never null** after construction (initialized as empty list in constructor).  
+- All string properties (`Name`, `DisplayName`, etc.) may be `null` or empty unless constrained by higher-level business logic (not enforced here).  
+- XML element names for `HardwareList` and `Channel` are explicitly fixed via `[XmlElement]` attributes: `"HardwareList"` and `"Channel"`, respectively.  
+- No ordering guarantees are enforced on the `Channel` list beyond preservation during serialization/deserialization.
+
+## 4. Dependencies  
+- **Depends on**:  
+  - `DTS.Common.XMLUtils.HardwareListXMLClass` (used as property type)  
+  - `DTS.Common.XMLUtils.ChannelXMLClass` (used as list element type)  
+  - `System.Xml.Serialization` (for `[XmlElement]` attribute)  
+  - Standard .NET types: `System`, `System.Collections.Generic`, `System.Linq`, `System.Text`, `System.Threading.Tasks`  
+
+- **Depended upon by**:  
+  - XML serialization/deserialization logic (e.g., `XmlSerializer`) in modules handling test setup export/import.  
+  - Likely consumed by higher-level classes such as `TestSetupXMLClass` or `TestSetupManager` (not visible in this file; inferred from namespace and naming conventions).  
+
+## 5. Gotchas  
+- `DisplayOrder` and `Position` are stored as `string` rather than numeric types, implying sorting/comparison must be handled explicitly by consumers (e.g., via `int.TryParse` or custom logic).  
+- No validation is performed on `Id` or `StaticGroupId` uniqueness or format (e.g., GUID validation); consumers must enforce consistency.  
+- The class has no custom `Equals`, `GetHashCode`, or comparison logic—reference equality applies.  
+- `Channel` is a `List<ChannelXMLClass>`; adding/removing items must be done via the list instance (e.g., `group.Channel.Add(...)`) rather than reassigning the property after construction.  
+- None identified from source alone.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/Channel.md

@@ -0,0 +1,65 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/Channel/ChannelXMLClass.cs
+generated_at: "2026-04-16T02:47:16.687650+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "37500596318a11d8"
+---
+
+# Channel
+
+### **Purpose**  
+This module defines the `ChannelXMLClass`, a data transfer object (DTO) used to serialize and deserialize channel configuration data to/from XML within the Test Setup export/import functionality of the DTS system. It encapsulates metadata and settings for a single measurement channel—including ISO-standardized and user-defined names, identifiers, disable status, and associated sensor/DAS linkage—enabling structured persistence and exchange of test setup configurations.
+
+---
+
+### **Public Interface**  
+
+#### **`ChannelXMLClass()`**  
+- **Signature**: `public ChannelXMLClass()`  
+- **Behavior**: Parameterless constructor that initializes the `Settings` property to a new instance of `SettingsXMLClass`. No other initialization occurs.
+
+#### **Properties**  
+All properties are public and auto-implemented (get/set). None include custom validation or side effects in their accessors.
+
+- **`ISOChannelName`** (`string`): Stores the ISO-standardized name of the channel.  
+- **`ISOCode`** (`string`): Stores the ISO-standardized code identifier for the channel.  
+- **`UserChannelName`** (`string`): Stores the user-defined name of the channel.  
+- **`UserCode`** (`string`): Stores the user-defined code identifier for the channel.  
+- **`Disabled`** (`string`): Represents the channel’s disabled state as a string (e.g., `"true"`/`"false"`). *Note: Not a boolean; stored as text.*  
+- **`Settings`** (`SettingsXMLClass`): Contains channel-specific settings. Marked with `[XmlElement("Settings")]`, meaning it will be serialized as a nested `<Settings>` element (not an attribute or wrapper). Initialized in constructor.  
+- **`SensorId`** (`string`): Identifier linking the channel to a physical sensor.  
+- **`DASId`** (`string`): Identifier for the Data Acquisition System (DAS) associated with this channel.  
+- **`DASChannelIdx`** (`string`): Index of the channel within the DAS (stored as string, not integer).  
+- **`TestSetupOrder`** (`string`): Order index of the channel within its test setup (string-typed).  
+- **`GroupOrder`** (`string`): Order index of the channel within its group (string-typed).  
+
+---
+
+### **Invariants**  
+- The `Settings` property is **always non-null** after construction due to initialization in the constructor.  
+- All properties are nullable (`string`); no runtime guarantees exist for non-empty values (e.g., `ISOChannelName` or `UserCode` may be `null` or empty).  
+- The `Disabled` property is a string, not a boolean—consumers must interpret `"true"`/`"false"` (case sensitivity not specified in source).  
+- XML serialization uses `[XmlElement("Settings")]` for `Settings`, ensuring the nested element is named exactly `"Settings"` (not `"SettingsXML"` or similar).  
+
+---
+
+### **Dependencies**  
+- **Internal Dependencies**:  
+  - `DTS.Common.XMLUtils.SettingsXMLClass` (referenced as `Settings` property type).  
+  - Standard .NET types: `System.Xml.Serialization` (for `[XmlElement]` attribute).  
+- **External Dependencies**:  
+  - This class is part of the `DTS.Common.XMLUtils` namespace, implying it is used in XML serialization contexts (e.g., `XmlSerializer`).  
+  - Likely consumed by higher-level test setup export/import modules (e.g., classes handling `TestSetup`, `Group`, or `Channel` hierarchies), though these are not visible in this file.  
+
+---
+
+### **Gotchas**  
+- **String-typed numeric fields**: `DASChannelIdx`, `TestSetupOrder`, and `GroupOrder` are `string` instead of `int`, despite representing indices/orders. Consumers must parse manually if numeric operations are needed.  
+- **`Disabled` is a string**: Not a `bool`, increasing risk of misinterpretation (e.g., `"True"` vs `"true"` case sensitivity, or `"1"`/`"0"` if used elsewhere).  
+- **No validation**: The class performs no validation on property values (e.g., `ISOCode` and `UserCode` may be identical or empty).  
+- **Constructor-only initialization**: `Settings` is only initialized in the parameterless constructor; if a parameterized constructor were added later (not present here), `Settings` could be `null` unless explicitly handled.  
+- **No XML namespace or schema metadata**: The class lacks `[XmlRoot]`, `[XmlType]`, or namespace attributes—serialization behavior depends on the consuming `XmlSerializer` context.  
+
+*None identified beyond the above.*

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/Channel/Settings.md

@@ -0,0 +1,57 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/Channel/Settings/SettingsXMLClass.cs
+generated_at: "2026-04-16T02:46:13.802939+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "411f1f2a52576ae2"
+---
+
+# Settings
+
+## 1. Purpose  
+`SettingsXMLClass` is a data transfer object (DTO) used to serialize and deserialize channel-specific configuration settings in XML format within the DTS.CommonCore XML export/import pipeline. It encapsulates a fixed set of string-based properties representing calibration, signal conditioning, and user-defined parameters for a test setup channel—specifically intended for use in test setup export workflows (as indicated by the namespace path `TestSetupExportXML`). It serves as a schema-agnostic container for settings that are likely mapped to XML elements during serialization/deserialization, but does not perform XML I/O itself.
+
+## 2. Public Interface  
+All members are public read-write properties of type `string`. No methods, constructors, or static members are defined.
+
+- `public string FilterClass { get; set; }`  
+  Represents the filter class configuration for the channel (e.g., "LowPass", "HighPass").  
+- `public string Polarity { get; set; }`  
+  Represents the signal polarity setting (e.g., "AC", "DC", "AC/DC").  
+- `public string Range { get; set; }`  
+  Represents the measurement or input range setting (e.g., "±10V", "4–20mA").  
+- `public string ZeroMethod { get; set; }`  
+  Specifies the zeroing method applied (e.g., "Auto", "Manual", "None").  
+- `public string ZeroMethodStart { get; set; }`  
+  Specifies the zeroing method used at the start of a measurement sequence.  
+- `public string ZeroMethodEnd { get; set; }`  
+  Specifies the zeroing method used at the end of a measurement sequence.  
+- `public string InitialOffset { get; set; }`  
+  Represents an initial offset value applied to the channel (as a string, likely numeric).  
+- `public string UserValue1 { get; set; }`  
+  A generic user-defined string field (purpose context-dependent).  
+- `public string UserValue2 { get; set; }`  
+  A generic user-defined string field (purpose context-dependent).  
+- `public string UserValue3 { get; set; }`  
+  A generic user-defined string field (purpose context-dependent).  
+
+## 3. Invariants  
+- All properties are nullable (`null` is a valid value).  
+- No validation or normalization is performed on property values (e.g., no enum enforcement, no format checking).  
+- The class imposes no ordering constraints on property serialization/deserialization (relies on underlying XML serializer behavior, e.g., `XmlSerializer` default ordering).  
+- No business logic or side effects occur on property access or assignment.
+
+## 4. Dependencies  
+- **Depends on**: `System`, `System.Collections.Generic`, `System.Linq`, `System.Text`, `System.Threading.Tasks` (standard .NET libraries).  
+- **Used by**: Likely consumed by XML serialization/deserialization logic elsewhere in `DTS.Common.XMLUtils` (e.g., in classes responsible for exporting/importing `TestSetup` structures).  
+- **No external project dependencies** are evident from this file alone.
+
+## 5. Gotchas  
+- **String-based representation of typed data**: All settings are stored as `string`, despite likely representing numeric, enum, or structured values (e.g., `Range`, `InitialOffset`). Consumers must handle parsing and validation externally.  
+- **Ambiguous `UserValue*` fields**: The semantic meaning of `UserValue1`, `UserValue2`, and `UserValue3` is not defined in this class and must be inferred from context (e.g., documentation, usage in other modules).  
+- **No XML attributes**: The class lacks `[XmlElement]`, `[XmlAttribute]`, or `[DataContract]` attributes, implying either:  
+  - It relies on default XML serializer member naming (e.g., property names map directly to element names), or  
+  - It is intended for use with a custom serializer that infers structure differently.  
+- **No immutability or defensive copying**: Instances are mutable and share references if passed by reference—no thread-safety guarantees.  
+- **None identified from source alone.**

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/HardwareList.md

@@ -0,0 +1,39 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/HardwareList/HardwareListXMLClass.cs
+generated_at: "2026-04-16T02:47:05.705813+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "4759260eb4cc44fe"
+---
+
+# HardwareList
+
+### 1. **Purpose**  
+This module defines a data contract class (`HardwareListXMLClass`) used for serializing and deserializing a list of hardware identifiers (as strings) to/from XML. It serves as a structured representation of hardware components associated with a test setup, specifically within the `DTS.Common.XMLUtils` namespace, and is intended for use with .NET’s `XmlSerializer` to handle XML persistence or exchange in test configuration workflows.
+
+### 2. **Public Interface**  
+- **`HardwareListXMLClass()`**  
+  Parameterless constructor initializing the `Hardware` property to an empty `List<string>`. Required for `XmlSerializer` compatibility.
+
+- **`List<string> Hardware { get; set; }`**  
+  Public property annotated with `[XmlElement("Hardware")]`. Contains the list of hardware identifiers (each a `string`). During XML serialization/deserialization, each element in this list is serialized as a `<Hardware>` XML element (e.g., `<Hardware>DeviceA</Hardware>`).
+
+### 3. **Invariants**  
+- The `Hardware` list is **never null**—it is initialized to an empty list in the constructor and remains so unless explicitly reassigned.  
+- All items in the `Hardware` list are expected to be non-null `string` values (though the class itself does not enforce this at runtime; nulls would serialize as empty `<Hardware />` elements).  
+- XML element names for list entries are strictly `"Hardware"` (case-sensitive, per `[XmlElement("Hardware")]`).  
+
+### 4. **Dependencies**  
+- **Depends on**:  
+  - `System.Xml.Serialization` (for `[XmlElement]` attribute).  
+  - `System.Collections.Generic` (for `List<T>`).  
+- **Used by**: Likely consumed by higher-level XML serialization logic in the `DTS.Common.XMLUtils` namespace (e.g., parent classes like `TestSetupXMLClass` or similar), though no direct usage is visible in this file.  
+- **No external project/module dependencies** beyond standard .NET libraries (as inferred from `using` directives).
+
+### 5. **Gotchas**  
+- **Null safety**: While the constructor initializes `Hardware`, external code could reassign `Hardware = null`, which would cause `XmlSerializer` to omit the element entirely (not serialize an empty list). Consumers must ensure the list remains non-null if `<Hardware>` elements are required.  
+- **No validation**: The class performs no validation on hardware identifiers (e.g., no checks for duplicates, format, or non-empty strings). Empty strings (`""`) or whitespace-only entries are permitted.  
+- **Serialization behavior**: Because `[XmlElement]` is used (not `[XmlArray]`), the list is flattened directly into repeated `<Hardware>` elements—no wrapper element (e.g., `<HardwareList>`) is generated. This matches typical XML schema expectations for "bag-like" collections.  
+- **No versioning or extensibility hooks**: The class is simple and immutable in structure; adding new fields would require careful versioning consideration if backward compatibility with existing XML is needed.  
+- **None identified from source alone.**

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/HardwareList/Hardware.md

@@ -0,0 +1,35 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/Groups/Group/HardwareList/Hardware/HardwareXMLClass.cs
+generated_at: "2026-04-16T02:46:03.346298+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "deba3553ae46d24d"
+---
+
+# Hardware
+
+### 1. **Purpose**  
+The `HardwareXMLClass` is a simple data transfer object (DTO) used to serialize or deserialize a single hardware identifier within XML-based test setup configurations. It exists to model a `<Hardware>` element in XML structures—specifically under the `HardwareList/Hardware` hierarchy—enabling structured handling of hardware references during test setup export/import operations. It plays a minimal, passive role: holding a string value representing a hardware item without business logic.
+
+### 2. **Public Interface**  
+- **`HardwareXMLClass`**  
+  - **Properties**:  
+    - `public string Hardware { get; set; }`  
+      Gets or sets the hardware identifier as a string. This property corresponds to the inner text of the `<Hardware>` XML element when serialized/deserialized.
+
+### 3. **Invariants**  
+- The `Hardware` property may be `null` or an empty string (`""`) unless constrained by higher-level validation logic (not present in this class).  
+- No validation, normalization, or transformation is performed on the `Hardware` value within this class.  
+- The class has no constructor-defined invariants; the default parameterless constructor is implicitly available.
+
+### 4. **Dependencies**  
+- **Internal**: Depends only on core .NET libraries (`System`, `System.Collections.Generic`, etc.), but none of these are actively used beyond basic language features.  
+- **External usage**: Inferred from the namespace (`DTS.Common.XMLUtils`) and file path (`TestSetupExportXML/.../HardwareXMLClass.cs`), this class is part of a larger XML serialization/deserialization pipeline for test setups. It is likely consumed by XML serialization frameworks (e.g., `System.Xml.Serialization`) or custom XML readers/writers in the `DTS.Common.XMLUtils` namespace.  
+- **Depended on by**: Unknown from source alone; likely used in conjunction with other classes in the `DTS.Common.XMLUtils` namespace (e.g., `HardwareListXMLClass`, `TestSetupXMLClass`), but no direct references are visible here.
+
+### 5. **Gotchas**  
+- **No validation or semantics**: The `Hardware` property accepts any string value, including whitespace-only or malformed identifiers. Consumers must enforce domain-specific constraints (e.g., hardware ID format, existence in a registry).  
+- **No XML attribute customization**: The class lacks `[XmlElement]`, `[DataContract]`, or similar attributes—its XML mapping behavior depends entirely on the serializer configuration (e.g., default `XmlSerializer` behavior would map `Hardware` to a `<Hardware>` element).  
+- **Minimal structure**: As a DTO with only one property, it may be overkill compared to using `string` directly—consider whether this wrapper adds sufficient value (e.g., extensibility, future fields) to justify its existence.  
+- **None identified from source alone.**

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/LevelTriggers.md

@@ -0,0 +1,37 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/LevelTriggers/LevelTriggersXMLClass.cs
+generated_at: "2026-04-16T02:46:33.893862+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "9dbcb9d3e3c73c05"
+---
+
+# LevelTriggers
+
+### 1. **Purpose**  
+This module defines a serializable data structure (`LevelTriggersXMLClass`) used to represent a collection of level triggers in XML format, specifically for export operations within the DTS system. It serves as the root container class for XML serialization/deserialization of `LevelTrigger` configurations, enabling persistence and interchange of trigger definitions in a standardized XML schema.
+
+### 2. **Public Interface**  
+- **`LevelTriggersXMLClass`**  
+  - **`List<LevelTriggerXMLClass> LevelTriggers { get; set; }`**  
+    A public property annotated with `[XmlElement("LevelTrigger")]`, indicating that each element in the list will be serialized as a `<LevelTrigger>` XML element. The property supports both reading and writing, and the list itself may be `null` unless explicitly initialized.
+
+### 3. **Invariants**  
+- The `LevelTriggers` property must be a `List<LevelTriggerXMLClass>` (or `null`) — no other collection type is enforced by the class itself.  
+- During XML serialization, each item in `LevelTriggers` will be serialized as a `<LevelTrigger>` element (due to the `[XmlElement("LevelTrigger")]` attribute).  
+- The class itself is a plain DTO with no validation logic; it does not enforce non-nullability or ordering constraints on the list contents.  
+- The class is not thread-safe; concurrent access/modification of `LevelTriggers` is not protected.
+
+### 4. **Dependencies**  
+- **Dependencies *on* this module**:  
+  - `System.Xml.Serialization` — used for XML serialization attributes (`[XmlElement]`).  
+  - `DTS.Common.XMLUtils.LevelTriggerXMLClass` — referenced as the generic type argument in `List<LevelTriggerXMLClass>` (imported from the same namespace, though not shown in this file).  
+- **Dependencies *of* this module**:  
+  - This module is part of `DTS.Common.XMLUtils` namespace and likely consumed by XML serialization/deserialization utilities elsewhere in the codebase (e.g., export/import services), but no explicit external dependencies beyond .NET framework types are declared.
+
+### 5. **Gotchas**  
+- The `LevelTriggers` list is not initialized by default — deserialization will leave it `null` unless the XML contains at least one `<LevelTrigger>` element *and* the serializer is configured to instantiate collections on missing elements (which `XmlSerializer` does *not* do by default). Developers must manually initialize the list (e.g., via constructor or before adding items) to avoid `NullReferenceException`.  
+- The class name `LevelTriggersXMLClass` (plural) suggests a collection, but the property is named `LevelTriggers` (also plural), which may cause redundancy in naming (e.g., `xmlClass.LevelTriggers.LevelTriggers` in code).  
+- No documentation or validation is present for the contents of `LevelTriggerXMLClass`, so correctness relies on downstream consumers adhering to expected schema.  
+- None identified from source alone.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/LevelTriggers/LevelTrigger.md

@@ -0,0 +1,53 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/LevelTriggers/LevelTrigger/LevelTriggerXMLClass.cs
+generated_at: "2026-04-16T02:47:18.228015+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "290fe3e17a2fe8dc"
+---
+
+# LevelTrigger
+
+## 1. Purpose  
+This module defines a data contract class (`LevelTriggerXMLClass`) used for serializing and deserializing level trigger configuration data to and from XML. It serves as a structured representation of threshold-based trigger conditions (e.g., high/low limits, range/out-of-range zones) for sensor channels in the DTS system, enabling persistence and exchange of trigger setup configurations via XML.
+
+## 2. Public Interface  
+The class exposes only public properties (all auto-implemented) annotated with `[XmlAttribute]`, indicating they are serialized as XML attributes (not elements). All properties are of type `string`.
+
+- **`GroupChannelId`** (`string`): Identifier for the logical group containing the channel. Serialized as an XML attribute.
+- **`HardwareChannelId`** (`string`): Identifier for the physical hardware channel. Serialized as an XML attribute.
+- **`SensorSerialNumber`** (`string`): Serial number of the associated sensor. Serialized as an XML attribute.
+- **`GreaterThanEnabled`** (`string`): Flag indicating whether the "greater than" threshold is active. Serialized as an XML attribute.
+- **`GreaterThanValue`** (`string`): Threshold value for the "greater than" condition. Serialized as an XML attribute.
+- **`LessThanEnabled`** (`string`): Flag indicating whether the "less than" threshold is active. Serialized as an XML attribute.
+- **`LessThanValue`** (`string`): Threshold value for the "less than" condition. Serialized as an XML attribute.
+- **`TriggerInside`** (`string`): Flag indicating whether triggering on values *inside* a defined range is enabled. Serialized as an XML attribute.
+- **`TriggerOutside`** (`string`): Flag indicating whether triggering on values *outside* a defined range is enabled. Serialized as an XML attribute.
+- **`InsideLowerEU`** (`string`): Lower bound (in engineering units) for the "inside" range. Serialized as an XML attribute.
+- **`InsideUpperEU`** (`string`): Upper bound (in engineering units) for the "inside" range. Serialized as an XML attribute.
+- **`OutsideLowerEU`** (`string`): Lower bound (in engineering units) for the "outside" range. Serialized as an XML attribute.
+- **`OutsideUpperEU`** (`string`): Upper bound (in engineering units) for the "outside" range. Serialized as an XML attribute.
+
+*Note:* All values are stored as strings; interpretation (e.g., parsing booleans or numeric thresholds) is deferred to consumers.
+
+## 3. Invariants  
+- **No validation is performed** within the class itself. Values (e.g., `GreaterThanValue`, `InsideLowerEU`) are stored as-is without type conversion or range checking.
+- **All properties are optional** at the class level—`null` or empty strings are permitted and will serialize as absent attributes (unless `XmlSerializer` is configured otherwise, but the source provides no such configuration).
+- **No ordering guarantees** exist for XML attributes during serialization; the `XmlSerializer` does not preserve property declaration order in the output XML.
+
+## 4. Dependencies  
+- **Depends on**:  
+  - `System.Xml.Serialization` (for `[XmlAttribute]` and `XmlSerializer` usage).  
+  - Standard .NET libraries (`System`, `System.Collections.Generic`, `System.Linq`, `System.Text`, `System.Threading.Tasks`), though these are not directly used in the class logic.  
+- **Used by**:  
+  - Other components in the `DTS.Common.XMLUtils` namespace (e.g., serializers/deserializers for test setup configurations). The file path (`TestSetupExportXML/.../LevelTriggerXMLClass.cs`) implies integration into test setup export workflows, likely consumed by classes handling `LevelTrigger` objects or XML export pipelines.
+
+## 5. Gotchas  
+- **String-based numeric/boolean fields**: Thresholds and flags are stored as `string` (e.g., `"true"`/`"false"`, `"10.5"`), requiring consumers to parse them. No validation ensures `GreaterThanValue` is numeric or `GreaterThanEnabled` is a valid boolean string.  
+- **Ambiguous range semantics**: The coexistence of `GreaterThan/LessThan` and `TriggerInside/TriggerOutside` suggests overlapping functionality (e.g., single-threshold vs. range-based triggers), but the source provides no guidance on how these interact (e.g., are they mutually exclusive? additive?).  
+- **No null-safety or default values**: If an XML attribute is missing, the corresponding property will be `null` after deserialization, which may cause runtime errors if consumers assume non-null.  
+- **No documentation of expected formats**: Units (e.g., "EU" in `InsideLowerEU`) are implied but not defined; consumers must infer or rely on external documentation.  
+- **Historical quirk**: The class name includes `LevelTrigger` but resides in a `TestSetup`-related path, suggesting it may be part of a legacy or test-specific serialization subset—use with caution in non-test contexts.  
+
+None identified beyond the above.

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/MetaDatas.md

@@ -0,0 +1,41 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/MetaDatas/MetaDatasXMLClass.cs
+generated_at: "2026-04-16T02:46:25.949138+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "2c419608c1c07249"
+---
+
+# MetaDatas
+
+## 1. Purpose  
+This module defines a serializable container class (`MetaDatasXMLClass`) for holding a collection of metadata entries (`MetaDataXMLClass` objects) in XML format. It serves as the root element for XML serialization/deserialization of metadata associated with test setups, enabling structured persistence and exchange of metadata in a standardized XML schema.
+
+## 2. Public Interface  
+- **`MetaDatasXMLClass`**  
+  - **Property**: `public List<MetaDataXMLClass> MetaDatas { get; set; }`  
+    - A list of `MetaDataXMLClass` instances.  
+    - Serialized as repeated `<MetaData>` XML elements (due to `[XmlElement("MetaData")]` attribute).  
+    - May be `null` if not initialized; no automatic initialization is performed by the class.  
+
+## 3. Invariants  
+- The `MetaDatas` list must contain only instances of `MetaDataXMLClass` (or its subclasses, if any) to maintain XML schema consistency.  
+- During XML serialization, each item in `MetaDatas` must be serializable as an XML element named `"MetaData"` (per the `[XmlElement]` attribute).  
+- No validation is performed on the contents of `MetaDatas` (e.g., null checks, duplicates, or semantic correctness of metadata values); this is left to callers or downstream consumers.  
+
+## 4. Dependencies  
+- **Depends on**:  
+  - `System.Collections.Generic` (for `List<T>`)  
+  - `System.Xml.Serialization` (for `[XmlElement]` attribute)  
+  - `DTS.Common.XMLUtils.MetaDataXMLClass` (referenced as the element type in `MetaDatas` list; assumed to be defined in the same namespace, though not included in source).  
+- **Depended on by**:  
+  - Presumably used by XML serialization/deserialization logic elsewhere in `DTS.Common.XMLUtils` (e.g., for exporting/importing test setup configurations).  
+  - No direct usage is visible in the provided snippet; inferred from namespace and naming conventions.  
+
+## 5. Gotchas  
+- **Null safety**: The `MetaDatas` property is not auto-initialized; callers must explicitly instantiate the list (e.g., `new MetaDatasXMLClass { MetaDatas = new List<MetaDataXMLClass>() }`) before adding items, or risk `NullReferenceException` during serialization or enumeration.  
+- **No custom serialization logic**: The class relies entirely on `XmlSerializer` behavior; no `IXmlSerializable` implementation or custom serialization hooks are present.  
+- **Assumed `MetaDataXMLClass` structure**: The definition and serialization behavior of `MetaDataXMLClass` (its properties, attributes, and required XML structure) are not provided here, making it impossible to fully specify constraints on `MetaDatas` contents.  
+- **No versioning or schema evolution support**: The class lacks attributes like `XmlRoot` or `XmlIgnore`, suggesting it is intended for a fixed, internal schema with no backward/forward compatibility handling.  
+- **None identified from source alone.**

enriched-qwen3-coder-next/Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/MetaDatas/MetaData.md

@@ -0,0 +1,57 @@
+---
+source_files:
+  - Common/DTS.CommonCore/XMLUtils/TestSetupExportXML/TestSetups/TestSetup/MetaDatas/MetaData/MetaDataXMLClass.cs
+generated_at: "2026-04-16T02:46:52.906159+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "ec2de2e83ab3f98b"
+---
+
+# MetaData
+
+## 1. Purpose  
+`MetaDataXMLClass` is a data transfer object (DTO) used for serializing and deserializing metadata associated with test setups in XML format. It encapsulates key identifying and descriptive attributes—such as the target test object, setup name, property name, property value, optional flag, and version—into a structure compatible with .NET’s `XmlSerializer`. This class enables persistent storage or exchange of test setup metadata in a standardized XML representation, likely used during test configuration export/import workflows.
+
+## 2. Public Interface  
+The class exposes only auto-implemented public properties; no methods or constructors are defined in the source.
+
+- **`string TestObject { get; set; }`**  
+  Gets or sets the name of the test object the metadata applies to. Serialized as an XML attribute.
+
+- **`string SetupName { get; set; }`**  
+  Gets or sets the name of the test setup. Serialized as an XML attribute.
+
+- **`string PropName { get; set; }`**  
+  Gets or sets the name of the property being described. Serialized as an XML attribute.
+
+- **`string PropValue { get; set; }`**  
+  Gets or sets the value of the property. Serialized as an XML attribute.
+
+- **`string Optional { get; set; }`**  
+  Gets or sets a string representation (e.g., `"true"`/`"false"`) indicating whether the property is optional. Serialized as an XML attribute.
+
+- **`string Version { get; set; }`**  
+  Gets or sets the version string associated with this metadata entry. Serialized as an XML attribute.
+
+All properties are decorated with `[XmlAttribute]`, meaning they will appear as attributes on the root XML element during serialization.
+
+## 3. Invariants  
+- All properties are nullable reference types (no explicit nullability annotations in source), but XML serialization will serialize `null` values as absent attributes only if the property is not set; otherwise, empty strings will serialize as `=""`.
+- The class assumes XML attribute names match the property names exactly (`TestObject`, `SetupName`, etc.).
+- No validation is performed on property values (e.g., no checks for empty strings, format constraints on `Version`, or boolean parsing for `Optional`). Consumers must handle parsing and validation externally.
+
+## 4. Dependencies  
+- **Dependencies on external modules**:  
+  - `System.Xml.Serialization` (for `[XmlAttribute]` attribute and `XmlSerializer` usage).  
+  - Standard .NET libraries (`System`, `System.Collections.Generic`, `System.Linq`, `System.Text`, `System.Threading.Tasks`), though only `System.Xml.Serialization` is directly used.
+
+- **Dependencies *by* this module**:  
+  - This class is likely consumed by XML serialization/deserialization logic elsewhere in `DTS.Common.XMLUtils` or downstream modules (e.g., test setup export/import utilities).  
+  - No explicit usages are visible in this file, but its purpose implies integration with XML I/O components.
+
+## 5. Gotchas  
+- **`Optional` is a string, not a bool**: Despite its name, the `Optional` property is serialized/deserialized as a string (e.g., `"true"`/`"false"`), not a boolean. Consumers must manually parse it (e.g., via `bool.TryParse`) to avoid runtime errors or misinterpretation.  
+- **No constructor or initialization logic**: Instances must be created and populated manually; no factory methods or default value assignments exist.  
+- **Case sensitivity**: XML attribute names are case-sensitive and match the C# property names exactly (e.g., `testobject` would not deserialize correctly).  
+- **No versioning or schema evolution support**: The class has no mechanism to handle backward/forward compatibility (e.g., unknown attributes, missing fields), which may cause issues if XML schemas evolve.  
+- **No documentation on expected values**: The semantics of `TestObject`, `SetupName`, and `Version` formats (e.g., GUIDs, paths, semantic versions) are not specified in this file.