reader-integration-kit 1.4.2__py3-none-win_amd64.whl

reader_integration_kit/structures/library_info.py

@@ -0,0 +1,74 @@
+"""
+Library information structure containing version and build metadata.
+This matches the C LibraryInfo structure.
+"""
+from ctypes import Structure, c_char
+
+
+class LibraryInfo(Structure):
+    """Library information structure with version and build metadata."""
+    
+    _fields_ = [
+        ("Name", c_char * 256),
+        ("InternalName", c_char * 256),
+        ("Comments", c_char * 512),
+        ("CompanyName", c_char * 256),
+        ("CompanyCopyright", c_char * 512),
+        ("LicenseText", c_char * 1024),
+        ("FileDescription", c_char * 1024),
+        ("SemVer", c_char * 256),
+        ("BuildVer", c_char * 256),
+        ("BumpType", c_char * 256),
+        ("BuildNumber", c_char * 256),
+        ("Branch", c_char * 256),
+        ("BuildURL", c_char * 1024),
+        ("BuildType", c_char * 256),
+        ("BuildDate", c_char * 256),
+        ("BuildPlatform", c_char * 256),
+        ("BuildToolchain", c_char * 256),
+        ("PullRequest", c_char * 256),
+        ("PullRequestBranch", c_char * 256),
+        ("PullRequestSlug", c_char * 256),
+        ("RepoSlug", c_char * 256),
+        ("Commit", c_char * 256),
+        ("CommitMessage", c_char * 1024),
+        ("CommitURL", c_char * 1024),
+        ("SourceDir", c_char * 1024),
+        ("IsAlphaBuild", c_char * 256),
+        ("InformationalVersion", c_char * 512),
+        ("VersionString", c_char * 256),
+    ]
+    
+    def to_dict(self) -> dict:
+        """Convert the structure to a dictionary."""
+        return {
+            "Name": self.Name.decode("utf-8", errors="ignore"),
+            "InternalName": self.InternalName.decode("utf-8", errors="ignore"),
+            "Comments": self.Comments.decode("utf-8", errors="ignore"),
+            "CompanyName": self.CompanyName.decode("utf-8", errors="ignore"),
+            "CompanyCopyright": self.CompanyCopyright.decode("utf-8", errors="ignore"),
+            "LicenseText": self.LicenseText.decode("utf-8", errors="ignore"),
+            "FileDescription": self.FileDescription.decode("utf-8", errors="ignore"),
+            "SemVer": self.SemVer.decode("utf-8", errors="ignore"),
+            "BuildVer": self.BuildVer.decode("utf-8", errors="ignore"),
+            "BumpType": self.BumpType.decode("utf-8", errors="ignore"),
+            "BuildNumber": self.BuildNumber.decode("utf-8", errors="ignore"),
+            "Branch": self.Branch.decode("utf-8", errors="ignore"),
+            "BuildURL": self.BuildURL.decode("utf-8", errors="ignore"),
+            "BuildType": self.BuildType.decode("utf-8", errors="ignore"),
+            "BuildDate": self.BuildDate.decode("utf-8", errors="ignore"),
+            "BuildPlatform": self.BuildPlatform.decode("utf-8", errors="ignore"),
+            "BuildToolchain": self.BuildToolchain.decode("utf-8", errors="ignore"),
+            "PullRequest": self.PullRequest.decode("utf-8", errors="ignore"),
+            "PullRequestBranch": self.PullRequestBranch.decode("utf-8", errors="ignore"),
+            "PullRequestSlug": self.PullRequestSlug.decode("utf-8", errors="ignore"),
+            "RepoSlug": self.RepoSlug.decode("utf-8", errors="ignore"),
+            "Commit": self.Commit.decode("utf-8", errors="ignore"),
+            "CommitMessage": self.CommitMessage.decode("utf-8", errors="ignore"),
+            "CommitURL": self.CommitURL.decode("utf-8", errors="ignore"),
+            "SourceDir": self.SourceDir.decode("utf-8", errors="ignore"),
+            "IsAlphaBuild": self.IsAlphaBuild.decode("utf-8", errors="ignore"),
+            "InformationalVersion": self.InformationalVersion.decode("utf-8", errors="ignore"),
+            "VersionString": self.VersionString.decode("utf-8", errors="ignore"),
+        }
+

reader_integration_kit/structures/luid_response_information.py

@@ -0,0 +1,44 @@
+from ctypes import Structure, c_uint16, c_uint32
+from typing import Any
+
+class LuidResponseInformation(Structure):
+    """
+    Structure representing LUID response information from the reader.
+    """
+    _pack_ = 1
+    _fields_ = [
+        ("Luid", c_uint16),
+        ("ApplicationVersionPackedBcd", c_uint16),
+        ("BootloaderVersionUnpackedBcd", c_uint32),
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.Luid = kw.get("Luid", 0)
+        self.ApplicationVersionPackedBcd = kw.get("ApplicationVersionPackedBcd", args[0] if len(args) > 0 else 0)
+        self.BootloaderVersionUnpackedBcd = kw.get("BootloaderVersionUnpackedBcd", args[1] if len(args) > 1 else 0)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            "Luid": self.Luid,
+            "ApplicationVersionPackedBcd": self.ApplicationVersionPackedBcd,
+            "BootloaderVersionUnpackedBcd": self.BootloaderVersionUnpackedBcd,
+        }
+
+    def __str__(self):
+        return f"LUID: 0x{self.Luid:04X}, App Version: 0x{self.ApplicationVersionPackedBcd:04X}, Bootloader Version: 0x{self.BootloaderVersionUnpackedBcd:08X}"
+
+    def __repr__(self):
+        return (f"LuidResponseInformation(luid=0x{self.Luid:04X}, "
+                f"application_version=0x{self.ApplicationVersionPackedBcd:04X}, "
+                f"bootloader_version=0x{self.BootloaderVersionUnpackedBcd:08X})")
+    
+    def __eq__(self, other):
+        return (isinstance(other, LuidResponseInformation) and
+                self.Luid == other.Luid and
+                self.ApplicationVersionPackedBcd == other.ApplicationVersionPackedBcd and
+                self.BootloaderVersionUnpackedBcd == other.BootloaderVersionUnpackedBcd)
+    
+    def __ne__(self, other):
+        return not self.__eq__(other)

reader_integration_kit/structures/microcontroller_firmware_version.py

@@ -0,0 +1,38 @@
+from ctypes import Structure, c_uint8, c_int32
+from typing import Any
+
+
+class MicrocontrollerFirmwareVersion(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("MajorHigh", c_uint8),
+        ("MajorLow", c_uint8),
+        ("MinorHigh", c_uint8),
+        ("MinorLow", c_uint8),
+        ("MicrocontrollerType", c_int32),  # enum class in C++ uses int (4 bytes)
+        ("ModuleType", c_int32),  # enum class in C++ uses int (4 bytes)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.MinorHigh = kw.get("MinorHigh", 0)
+        self.MinorLow = kw.get("MinorLow", 0)
+        self.MajorHigh = kw.get("MajorHigh", 0)
+        self.MajorLow = kw.get("MajorLow", 0)
+        self.MicrocontrollerType = kw.get("MicrocontrollerType", 0)
+        self.ModuleType = kw.get("ModuleType", 0)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            "MajorHigh": self.MajorHigh,
+            "MajorLow": self.MajorLow,
+            "MinorHigh": self.MinorHigh,
+            "MinorLow": self.MinorLow,
+            "MicrocontrollerType": self.MicrocontrollerType,
+            "ModuleType": self.ModuleType,
+        }
+
+    def __str__(self):
+        return f"{self.MajorHigh}.{self.MajorLow}.{self.MinorHigh}.{self.MinorLow}"
+

reader_integration_kit/structures/nxp_sam_firmware_version.py

@@ -0,0 +1,38 @@
+from ctypes import Structure, c_uint8, c_int32
+from typing import Any
+
+
+class NxpSamFirmwareVersion(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("Major", c_uint8),
+        ("Minor", c_uint8),
+        ("Rfu", c_uint8),
+        ("Mode", c_uint8),
+        ("MicrocontrollerType", c_int32),  # enum class in C++ uses int (4 bytes)
+        ("SamType", c_int32),  # enum class in C++ uses int (4 bytes)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.Mode = kw.get("Mode", 0)
+        self.Rfu = kw.get("Rfu", 0)
+        self.Minor = kw.get("Minor", 0)
+        self.Major = kw.get("Major", 0)
+        self.SamType = kw.get("SamType", 0)
+        self.MicrocontrollerType = kw.get("MicrocontrollerType", 0)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            "Major": self.Major,
+            "Minor": self.Minor,
+            "Rfu": self.Rfu,
+            "Mode": self.Mode,
+            "MicrocontrollerType": self.MicrocontrollerType,
+            "SamType": self.SamType,
+        }
+
+    def __str__(self):
+        return f"{self.Major}.{self.Minor} Mode: {self.Mode}"
+

reader_integration_kit/structures/reader_configuration.py

@@ -0,0 +1,171 @@
+from ctypes import Structure, c_uint8, c_uint16
+from typing import Any
+
+class ReaderConfigurationStruct(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        # ReaderConfigurationBlock1
+        ("FacDigitCount", c_uint8),
+        ("IdDigitCount", c_uint8),
+        ("TotalStripLeadingParityCount", c_uint8),
+        ("TotalStripTrailingParityCount", c_uint8),
+        ("IdBitCount", c_uint8),
+        ("ExpectedBitCount", c_uint8),
+        ("IdAndFacDelimiter", c_uint8),
+        ("TerminationCharacter", c_uint8),
+        ("UseFixedLengthForFacAndId", c_uint8),
+        ("EnforceExpectedBitCount", c_uint8),
+        ("StripFacFromId", c_uint8),
+        ("SendFacAfterStrippingIt", c_uint8),
+        ("UseIdAndFacDelimiter", c_uint8),
+        ("DisableKeystrokeTerminationCharacter", c_uint8),
+        ("EnableContinuousRead", c_uint8),
+        ("DisableKeystroking", c_uint8),
+
+        # ReaderConfigurationBlock2
+        ("LegacyBitStreamTimeOutMs", c_uint16),
+        ("DataHoldTimeMs", c_uint16),
+        ("LockOutTimeMs", c_uint16),
+        ("KeyPressTimeMs", c_uint16),
+        ("KeyReleaseTimeMs", c_uint16),
+        ("EnableIdExtendedPrecision", c_uint8),
+        ("UseLowercaseHex", c_uint8),
+        ("EnableProxProEmulation", c_uint8),
+        ("EnableHexadecimalId", c_uint8),
+        ("EnableHexadecimalFac", c_uint8),
+        ("UseIndividualIdAndFacNumberFormats", c_uint8),
+        ("UseNumericKeypad", c_uint8),
+        ("ReaderSupportsReverseAllBytes", c_uint8),
+        ("ReaderSupportsAsciiExtended", c_uint8),
+        ("ReaderSupportsExtendedMode", c_uint8),
+        ("EnableRoswellMode", c_uint8),
+
+        # ReaderConfigurationBlock3
+        ("EnableRedLed", c_uint8),
+        ("EnableGreenLed", c_uint8),
+        ("EnableOemRelay", c_uint8),
+        ("EnableOemBeeper", c_uint8),
+        ("IsBootDevice", c_uint8),
+        ("UseLeadingCharacters", c_uint8),
+        ("EnabledSoftwareControlledLed", c_uint8),
+        ("UseHexadecimalForBothFacAndId", c_uint8),
+        ("InvertWiegandBits", c_uint8),
+        ("EnableBeepOnCardRead", c_uint8),
+        ("ReverseWiegandBits", c_uint8),
+        ("ReverseWiegandBytes", c_uint8),
+        ("UseDataInvert", c_uint8),
+        ("CardGoneCharacters", c_uint8 * 2),
+        ("LeadingCharacterCount", c_uint8),
+        ("TrailingCharacterCount", c_uint8),
+        ("LeadingTrailingCharacters", c_uint8 * 3),
+
+        # ReaderConfigurationBlock4
+        ("UseIndividualIdAndFacFixedLengths", c_uint8),
+        ("UseFixedLengthFac", c_uint8),
+        ("UseFixedLengthId", c_uint8),
+        ("CfgRb3", c_uint8),
+        ("CfgRb4", c_uint8),
+        ("EnableFacExtendedPrecision", c_uint8),
+        ("AzertyKeyboardShift", c_uint8),
+        ("EnableExtendedMode", c_uint8),
+
+        # ReaderConfigurationBlock5
+        ("DisableCardConfiguration", c_uint8),
+        ("CardType", c_uint16),
+        ("SetHighPriorityCardType", c_uint8),
+        ("JetMobileCompatibilityCharacter", c_uint8),
+        ("JetMobileCharacterCount", c_uint8),
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        for field_name, field_type in self._fields_:
+            if field_name in kw:
+                setattr(self, field_name, kw[field_name])
+            else:
+                # Handle array fields differently from scalar fields
+                if hasattr(field_type, '_length_'):
+                    array_instance = field_type()
+                    for i in range(field_type._length_):
+                        array_instance[i] = 0
+                    setattr(self, field_name, array_instance)
+                else:
+                    setattr(self, field_name, 0)
+
+    def __str__(self):
+        field_strings = []
+        for field_name, _ in self._fields_:
+            field_value = getattr(self, field_name)
+            if hasattr(field_value, '__len__') and not isinstance(field_value, str):
+                field_strings.append(f"{field_name}: {list(field_value)}")
+            else:
+                field_strings.append(f"{field_name}: {field_value}")
+        return "\n".join(field_strings)
+    
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return NotImplemented
+        return self.FacDigitCount == other.FacDigitCount and \
+            self.IdDigitCount == other.IdDigitCount and \
+            self.TotalStripLeadingParityCount == other.TotalStripLeadingParityCount and \
+            self.TotalStripTrailingParityCount == other.TotalStripTrailingParityCount and \
+            self.IdBitCount == other.IdBitCount and \
+            self.ExpectedBitCount == other.ExpectedBitCount and \
+            self.IdAndFacDelimiter == other.IdAndFacDelimiter and \
+            self.TerminationCharacter == other.TerminationCharacter and \
+            self.UseFixedLengthForFacAndId == other.UseFixedLengthForFacAndId and \
+            self.EnforceExpectedBitCount == other.EnforceExpectedBitCount and \
+            self.StripFacFromId == other.StripFacFromId and \
+            self.SendFacAfterStrippingIt == other.SendFacAfterStrippingIt and \
+            self.UseIdAndFacDelimiter == other.UseIdAndFacDelimiter and \
+            self.DisableKeystrokeTerminationCharacter == other.DisableKeystrokeTerminationCharacter and \
+            self.EnableContinuousRead == other.EnableContinuousRead and \
+            self.DisableKeystroking == other.DisableKeystroking and \
+            self.LegacyBitStreamTimeOutMs == other.LegacyBitStreamTimeOutMs and \
+            self.DataHoldTimeMs == other.DataHoldTimeMs and \
+            self.LockOutTimeMs == other.LockOutTimeMs and \
+            self.KeyPressTimeMs == other.KeyPressTimeMs and \
+            self.KeyReleaseTimeMs == other.KeyReleaseTimeMs and \
+            self.EnableIdExtendedPrecision == other.EnableIdExtendedPrecision and \
+            self.UseLowercaseHex == other.UseLowercaseHex and \
+            self.EnableProxProEmulation == other.EnableProxProEmulation and \
+            self.EnableHexadecimalId == other.EnableHexadecimalId and \
+            self.EnableHexadecimalFac == other.EnableHexadecimalFac and \
+            self.UseIndividualIdAndFacNumberFormats == other.UseIndividualIdAndFacNumberFormats and \
+            self.UseNumericKeypad == other.UseNumericKeypad and \
+            self.EnableRoswellMode == other.EnableRoswellMode and \
+            self.EnableRedLed == other.EnableRedLed and \
+            self.EnableGreenLed == other.EnableGreenLed and \
+            self.EnableOemRelay == other.EnableOemRelay and \
+            self.EnableOemBeeper == other.EnableOemBeeper and \
+            self.UseLeadingCharacters == other.UseLeadingCharacters and \
+            self.EnabledSoftwareControlledLed == other.EnabledSoftwareControlledLed and \
+            self.UseHexadecimalForBothFacAndId == other.UseHexadecimalForBothFacAndId and \
+            self.InvertWiegandBits == other.InvertWiegandBits and \
+            self.EnableBeepOnCardRead == other.EnableBeepOnCardRead and \
+            self.ReverseWiegandBits == other.ReverseWiegandBits and \
+            self.ReverseWiegandBytes == other.ReverseWiegandBytes and \
+            self.UseDataInvert == other.UseDataInvert and \
+            list(self.CardGoneCharacters) == list(other.CardGoneCharacters) and \
+            self.LeadingCharacterCount == other.LeadingCharacterCount and \
+            self.TrailingCharacterCount == other.TrailingCharacterCount and \
+            list(self.LeadingTrailingCharacters) == list(other.LeadingTrailingCharacters) and \
+            self.UseIndividualIdAndFacFixedLengths == other.UseIndividualIdAndFacFixedLengths and \
+            self.UseFixedLengthFac == other.UseFixedLengthFac and \
+            self.UseFixedLengthId == other.UseFixedLengthId and \
+            self.CfgRb3 == other.CfgRb3 and \
+            self.CfgRb4 == other.CfgRb4 and \
+            self.EnableFacExtendedPrecision == other.EnableFacExtendedPrecision and \
+            self.AzertyKeyboardShift == other.AzertyKeyboardShift and \
+            self.EnableExtendedMode == other.EnableExtendedMode and \
+            self.DisableCardConfiguration == other.DisableCardConfiguration and \
+            self.CardType == other.CardType and \
+            self.SetHighPriorityCardType == other.SetHighPriorityCardType and \
+            self.JetMobileCompatibilityCharacter == other.JetMobileCompatibilityCharacter and \
+            self.JetMobileCharacterCount == other.JetMobileCharacterCount
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result

reader_integration_kit/structures/reader_data.py

@@ -0,0 +1,49 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+from reader_integration_kit.enum import FieldDefinitionType
+
+class ReaderData(Structure):
+    _fields_ = [
+        ("DefinitionType", c_uint8),
+        ("EnhanceSecurityFlag", c_uint8),
+        ("FipsBitCount", c_uint8)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.DefinitionType = kw.get("DefinitionType", args[0] if len(args) > 0 else FieldDefinitionType.USER_FIELDS.value)
+        self.EnhanceSecurityFlag = kw.get("EnhanceSecurityFlag", args[1] if len(args) > 1 else 0)
+        self.FipsBitCount = kw.get("FipsBitCount", args[2] if len(args) > 2 else 0)
+
+    def __str__(self):
+        return (f"Definition type: {FieldDefinitionType(self.DefinitionType).name}\n"
+                f"Enhance security flag: {self.EnhanceSecurityFlag}\n"
+                f"Fips bit count: {self.FipsBitCount}\n")
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return self.DefinitionType == other.DefinitionType and self.EnhanceSecurityFlag == other.EnhanceSecurityFlag and self.FipsBitCount == other.FipsBitCount
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def to_dict(self):
+        return {
+            "DefinitionType": FieldDefinitionType(self.DefinitionType).name,
+            "EnhanceSecurityFlag": self.EnhanceSecurityFlag,
+            "FipsBitCount": self.FipsBitCount
+        }
+    
+    def to_bytes(self):
+        return bytes([self.DefinitionType, self.EnhanceSecurityFlag, self.FipsBitCount])
+
+    @classmethod
+    def from_bytes(cls, byte_array):
+        return cls(
+            DefinitionType=byte_array[0],
+            EnhanceSecurityFlag=byte_array[1],
+            FipsBitCount=byte_array[2]
+        )

reader_integration_kit/structures/reader_definition.py

@@ -0,0 +1,14 @@
+from ctypes import Structure, c_uint8
+
+from reader_integration_kit.structures.device_id import DeviceId
+from reader_integration_kit.structures.serial_port_settings import SerialPortSettings
+
+
+class ReaderDefinition(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("DeviceId", DeviceId),
+        ("ProtocolType", c_uint8),  # ProtocolType enum (byte in C++)
+        ("SerialPortSettings", SerialPortSettings),
+    ]
+

reader_integration_kit/structures/reader_metadata_struct.py

@@ -0,0 +1,195 @@
+from ctypes import Structure, c_char, c_uint8, c_int
+
+from reader_integration_kit.structures.microcontroller_firmware_version import MicrocontrollerFirmwareVersion
+from reader_integration_kit.structures.bluetooth_firmware_version import BluetoothFirmwareVersion
+from reader_integration_kit.structures.hid_se_sam_firmware_version import HidSeSamFirmwareVersion
+from reader_integration_kit.structures.nxp_sam_firmware_version import NxpSamFirmwareVersion
+from reader_integration_kit.structures.felica_sam_firmware_version import FelicaSamFirmwareVersion
+
+# Maximum string length for metadata fields (matches METADATA_MAX_STRING_LENGTH = 512)
+METADATA_MAX_STRING_LENGTH = 512
+
+
+class _AdvancedAttributes(Structure):
+    """Nested struct for internal Block2 attributes."""
+    _pack_ = 1
+    _fields_ = [
+        ("ReverseAllBytesSupported", c_uint8),
+        ("AsciiExtendedSupported", c_uint8),
+        ("RoswellModeEnabled", c_uint8),
+    ]
+
+
+class ReaderMetadataStruct(Structure):
+    """ReaderMetadataStruct - matches the C struct definition."""
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("Processor", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasProcessor", c_uint8),
+        ("HardwarePlatform", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasHardwarePlatform", c_uint8),
+        ("Product", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasProduct", c_uint8),
+        ("PartNumber", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasPartNumber", c_uint8),
+        ("ProductLine", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasProductLine", c_uint8),
+        ("ConfigurationCount", c_int),
+        ("HasConfigurationCount", c_uint8),
+        ("SerialNumber", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasSerialNumber", c_uint8),
+        ("ESN", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasESN", c_uint8),
+        ("InstalledHardware", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasInstalledHardware", c_uint8),
+        ("SupportedHardware", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasSupportedHardware", c_uint8),
+        # Raw boolean fields mirroring protocol layer's InstalledHardwareInformation.
+        # These provide direct, machine-readable access to hardware capabilities.
+        ("HwSupportedSamSe", c_uint8),
+        ("HwSupportedRfAms", c_uint8),
+        ("HwSupportedRf125", c_uint8),
+        ("HwSupportedRfLegic", c_uint8),
+        ("HwSupportedRfBle", c_uint8),
+        ("HwSupportedNxp", c_uint8),
+        ("HwSupportedRfHidBle", c_uint8),
+        ("HwSupportedFelica", c_uint8),
+        ("HwSupportedBeeper", c_uint8),
+        ("HwSupportedNano", c_uint8),
+        ("HwInstalledSamSe", c_uint8),
+        ("HwInstalledRfAms", c_uint8),
+        ("HwInstalledRf125", c_uint8),
+        ("HwInstalledRfLegic", c_uint8),
+        ("HwInstalledRfBle", c_uint8),
+        ("HwInstalledNxp", c_uint8),
+        ("HwInstalledRfHidBle", c_uint8),
+        ("HwInstalledFelica", c_uint8),
+        ("HasInstalledHardwareInfo", c_uint8),
+        ("FirmwareFilename", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasFirmwareFilename", c_uint8),
+        ("FirmwareVersion", c_char * METADATA_MAX_STRING_LENGTH),
+        ("HasFirmwareVersion", c_uint8),
+        ("ControllerApplicationVersion", MicrocontrollerFirmwareVersion),
+        ("HasControllerApplicationVersion", c_uint8),
+        ("ControllerBootloaderVersion", MicrocontrollerFirmwareVersion),
+        ("HasControllerBootloaderVersion", c_uint8),
+        ("ControllerRadioVersion", MicrocontrollerFirmwareVersion),
+        ("HasControllerRadioVersion", c_uint8),
+        ("RadioApplicationVersion", MicrocontrollerFirmwareVersion),
+        ("HasRadioApplicationVersion", c_uint8),
+        ("RadioBootloaderVersion", MicrocontrollerFirmwareVersion),
+        ("HasRadioBootloaderVersion", c_uint8),
+        ("RadioRadioVersion", MicrocontrollerFirmwareVersion),
+        ("HasRadioRadioVersion", c_uint8),
+        ("BluetoothVersion", BluetoothFirmwareVersion),
+        ("HasBluetoothVersion", c_uint8),
+        ("HidSeSamVersion", HidSeSamFirmwareVersion),
+        ("HasHidSeSamVersion", c_uint8),
+        ("NxpSamVersion", NxpSamFirmwareVersion),
+        ("HasNxpSamVersion", c_uint8),
+        ("FelicaSamVersion", FelicaSamFirmwareVersion),
+        ("HasFelicaSamVersion", c_uint8),
+        # Protocol type used to communicate with this reader (RikCommon::ProtocolType enum).
+        ("ProtocolType", c_uint8),
+        # Whether this reader supports extended configuration mode.
+        ("ReaderSupportsExtendedMode", c_uint8),
+        # Internal attributes derived from Block2 configuration.
+        ("AdvancedAttributes", _AdvancedAttributes),
+    ]
+
+    def _decode_string(self, field_name: str) -> str:
+        """Helper to decode a string field, handling null termination."""
+        field = getattr(self, field_name)
+        if field:
+            try:
+                return bytes(field).decode('utf-8').rstrip('\x00')
+            except (UnicodeDecodeError, AttributeError):
+                return ""
+        return ""
+
+    def to_dict(self) -> dict:
+        """Convert the struct to a dictionary, only including fields that are present."""
+        result = {}
+
+        # String fields with presence flags
+        if self.HasProcessor:
+            result["Processor"] = self._decode_string("Processor")
+        if self.HasHardwarePlatform:
+            result["HardwarePlatform"] = self._decode_string("HardwarePlatform")
+        if self.HasProduct:
+            result["Product"] = self._decode_string("Product")
+        if self.HasPartNumber:
+            result["PartNumber"] = self._decode_string("PartNumber")
+        if self.HasProductLine:
+            result["ProductLine"] = self._decode_string("ProductLine")
+        if self.HasConfigurationCount:
+            result["ConfigurationCount"] = self.ConfigurationCount
+        if self.HasSerialNumber:
+            result["SerialNumber"] = self._decode_string("SerialNumber")
+        if self.HasESN:
+            result["ESN"] = self._decode_string("ESN")
+        if self.HasInstalledHardware:
+            result["InstalledHardware"] = self._decode_string("InstalledHardware")
+        if self.HasSupportedHardware:
+            result["SupportedHardware"] = self._decode_string("SupportedHardware")
+
+        # Hardware capability booleans
+        if self.HasInstalledHardwareInfo:
+            result["InstalledHardwareInfo"] = {
+                "SupportedSamSe": bool(self.HwSupportedSamSe),
+                "SupportedRfAms": bool(self.HwSupportedRfAms),
+                "SupportedRf125": bool(self.HwSupportedRf125),
+                "SupportedRfLegic": bool(self.HwSupportedRfLegic),
+                "SupportedRfBle": bool(self.HwSupportedRfBle),
+                "SupportedNxp": bool(self.HwSupportedNxp),
+                "SupportedRfHidBle": bool(self.HwSupportedRfHidBle),
+                "SupportedFelica": bool(self.HwSupportedFelica),
+                "SupportedBeeper": bool(self.HwSupportedBeeper),
+                "SupportedNano": bool(self.HwSupportedNano),
+                "InstalledSamSe": bool(self.HwInstalledSamSe),
+                "InstalledRfAms": bool(self.HwInstalledRfAms),
+                "InstalledRf125": bool(self.HwInstalledRf125),
+                "InstalledRfLegic": bool(self.HwInstalledRfLegic),
+                "InstalledRfBle": bool(self.HwInstalledRfBle),
+                "InstalledNxp": bool(self.HwInstalledNxp),
+                "InstalledRfHidBle": bool(self.HwInstalledRfHidBle),
+                "InstalledFelica": bool(self.HwInstalledFelica),
+            }
+
+        if self.HasFirmwareFilename:
+            result["FirmwareFilename"] = self._decode_string("FirmwareFilename")
+        if self.HasFirmwareVersion:
+            result["FirmwareVersion"] = self._decode_string("FirmwareVersion")
+
+        # Firmware version structures
+        if self.HasControllerApplicationVersion:
+            result["ControllerApplicationVersion"] = self.ControllerApplicationVersion.to_dict()
+        if self.HasControllerBootloaderVersion:
+            result["ControllerBootloaderVersion"] = self.ControllerBootloaderVersion.to_dict()
+        if self.HasControllerRadioVersion:
+            result["ControllerRadioVersion"] = self.ControllerRadioVersion.to_dict()
+        if self.HasRadioApplicationVersion:
+            result["RadioApplicationVersion"] = self.RadioApplicationVersion.to_dict()
+        if self.HasRadioBootloaderVersion:
+            result["RadioBootloaderVersion"] = self.RadioBootloaderVersion.to_dict()
+        if self.HasRadioRadioVersion:
+            result["RadioRadioVersion"] = self.RadioRadioVersion.to_dict()
+        if self.HasBluetoothVersion:
+            result["BluetoothVersion"] = self.BluetoothVersion.to_dict()
+        if self.HasHidSeSamVersion:
+            result["HidSeSamVersion"] = self.HidSeSamVersion.to_dict()
+        if self.HasNxpSamVersion:
+            result["NxpSamVersion"] = self.NxpSamVersion.to_dict()
+        if self.HasFelicaSamVersion:
+            result["FelicaSamVersion"] = self.FelicaSamVersion.to_dict()
+
+        result["ProtocolType"] = self.ProtocolType
+        result["ReaderSupportsExtendedMode"] = bool(self.ReaderSupportsExtendedMode)
+        result["AdvancedAttributes"] = {
+            "ReverseAllBytesSupported": bool(self.AdvancedAttributes.ReverseAllBytesSupported),
+            "AsciiExtendedSupported": bool(self.AdvancedAttributes.AsciiExtendedSupported),
+            "RoswellModeEnabled": bool(self.AdvancedAttributes.RoswellModeEnabled),
+        }
+
+        return result
+