regula-documentreader-webclient 8.1.353.dev0__py3-none-any.whl → 8.1.355rc0__py3-none-any.whl

regula/documentreader/webclient/gen/models/rfid_graphics_info_result.py

@@ -1,90 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import ConfigDict, Field
-from typing import Any, ClassVar, Dict, List
-from regula.documentreader.webclient.gen.models.result import Result
-from regula.documentreader.webclient.gen.models.result_item import ResultItem
-from regula.documentreader.webclient.gen.models.t_original_rfid_graphics_info import TOriginalRFIDGraphicsInfo
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RFIDGraphicsInfoResult(ResultItem):
-    """
-    RFIDGraphicsInfoResult
-    """ # noqa: E501
-    t_original_rfid_graphics_info: TOriginalRFIDGraphicsInfo = Field(alias="TOriginalRFIDGraphicsInfo")
-    __properties: ClassVar[List[str]] = ["buf_length", "light", "list_idx", "page_idx", "result_type", "TOriginalRFIDGraphicsInfo"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RFIDGraphicsInfoResult from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of t_original_rfid_graphics_info
-        if self.t_original_rfid_graphics_info:
-            _dict['TOriginalRFIDGraphicsInfo'] = self.t_original_rfid_graphics_info.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RFIDGraphicsInfoResult from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "buf_length": obj.get("buf_length"),
-            "light": obj.get("light"),
-            "list_idx": obj.get("list_idx"),
-            "page_idx": obj.get("page_idx"),
-            "result_type": obj.get("result_type"),
-            "TOriginalRFIDGraphicsInfo": TOriginalRFIDGraphicsInfo.from_dict(obj["TOriginalRFIDGraphicsInfo"]) if obj.get("TOriginalRFIDGraphicsInfo") is not None else None
-        })
-        return _obj
-
-

regula/documentreader/webclient/gen/models/rfid_password_type.py

@@ -1,34 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import json
-from enum import Enum
-from typing_extensions import Self
-
-
-class RfidPasswordType(int, Enum):
-    """
-    Enumeration contains a set of constants specifying the rate of data exchange between the reader and the RFID-chip
-    """
-
-    """
-    allowed enum values
-    """
-    UNKNOWN = 0
-    MRZ = 1
-    CAN = 2
-    PIN = 3
-    PUK = 4
-    PIN_E_SIGN = 5
-    SAI = 6
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Self:
-        """Create an instance of RfidPasswordType from a JSON string"""
-        return cls(json.loads(json_str))
-
-

regula/documentreader/webclient/gen/models/rfid_pki_extension.py

@@ -1,81 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidPkiExtension(BaseModel):
-    """
-    Extension identifier (OID, ASCII string); Contents of the identifier in the format S1 (S2), where S1 – attribute name, S2 – identifier (OID string)
-    """ # noqa: E501
-    type: StrictStr = Field(description="Extension identifier (OID, ASCII string); Contents of the identifier in the format S1 (S2), where S1 – attribute name, S2 – identifier (OID string)", alias="Type")
-    data: StrictStr = Field(description="Extension binary data. Base64 encoded.", alias="Data")
-    __properties: ClassVar[List[str]] = ["Type", "Data"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RfidPkiExtension from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidPkiExtension from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Type": obj.get("Type"),
-            "Data": obj.get("Data")
-        })
-        return _obj
-
-

regula/documentreader/webclient/gen/models/rfid_raw_data.py

@@ -1,81 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidRawData(BaseModel):
-    """
-    RfidRawData
-    """ # noqa: E501
-    data: StrictStr = Field(alias="Data")
-    field_type: StrictInt = Field(alias="FieldType")
-    __properties: ClassVar[List[str]] = ["Data", "FieldType"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RfidRawData from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidRawData from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Data": obj.get("Data"),
-            "FieldType": obj.get("FieldType")
-        })
-        return _obj
-
-

regula/documentreader/webclient/gen/models/rfid_security_object.py

@@ -1,96 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Union
-from regula.documentreader.webclient.gen.models.parsing_notification_codes import ParsingNotificationCodes
-from regula.documentreader.webclient.gen.models.rfid_signer_info_ex import RfidSignerInfoEx
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidSecurityObject(BaseModel):
-    """
-    Structure is used to describe the contents of a single document security object (SO) and the results of its check within the context of the communication session with electronic document
-    """ # noqa: E501
-    version: Union[StrictFloat, StrictInt] = Field(description="Security object version", alias="Version")
-    object_type: StrictStr = Field(description="Identifier of the security object", alias="ObjectType")
-    file_reference: Union[StrictFloat, StrictInt] = Field(description="Reference to the source file of the security object data", alias="FileReference")
-    notifications: List[ParsingNotificationCodes] = Field(description="List of remarks arisen during the analysis of SO data structure.", alias="Notifications")
-    signer_infos: List[RfidSignerInfoEx] = Field(description="List of containers to store information about digital signature objects contained in the SO", alias="SignerInfos")
-    __properties: ClassVar[List[str]] = ["Version", "ObjectType", "FileReference", "Notifications", "SignerInfos"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RfidSecurityObject from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of each item in signer_infos (list)
-        _items = []
-        if self.signer_infos:
-            for _item_signer_infos in self.signer_infos:
-                if _item_signer_infos:
-                    _items.append(_item_signer_infos.to_dict())
-            _dict['SignerInfos'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidSecurityObject from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Version": obj.get("Version"),
-            "ObjectType": obj.get("ObjectType"),
-            "FileReference": obj.get("FileReference"),
-            "Notifications": obj.get("Notifications"),
-            "SignerInfos": [RfidSignerInfoEx.from_dict(_item) for _item in obj["SignerInfos"]] if obj.get("SignerInfos") is not None else None
-        })
-        return _obj
-
-

regula/documentreader/webclient/gen/models/rfid_session_data.py

@@ -1,150 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional, Union
-from regula.documentreader.webclient.gen.models.check_result import CheckResult
-from regula.documentreader.webclient.gen.models.rfid_access_control_info import RfidAccessControlInfo
-from regula.documentreader.webclient.gen.models.rfid_access_key import RfidAccessKey
-from regula.documentreader.webclient.gen.models.rfid_application import RfidApplication
-from regula.documentreader.webclient.gen.models.rfid_authentication_procedure_type import RfidAuthenticationProcedureType
-from regula.documentreader.webclient.gen.models.rfid_card_properties_ext import RfidCardPropertiesExt
-from regula.documentreader.webclient.gen.models.rfid_error_codes import RFIDErrorCodes
-from regula.documentreader.webclient.gen.models.rfid_security_object import RfidSecurityObject
-from regula.documentreader.webclient.gen.models.rfid_terminal import RfidTerminal
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidSessionData(BaseModel):
-    """
-    Structure is used to describe the results of work with the SDK within the context of the current communication session with electronic document
-    """ # noqa: E501
-    virtual_mode: Optional[StrictStr] = Field(default=None, description="Sign of virtual session when working with loaded data from a previous communication session with the electronic document", alias="VirtualMode")
-    sdk_version: Optional[StrictStr] = Field(default=None, description="Text SDKVersion value in format A.B (e.g. 3.1)", alias="SDKVersion")
-    driver_version: Optional[StrictStr] = Field(default=None, description="Text DriverVersion value in format A.B.C.D (e.g. 6.2.5.4)", alias="DriverVersion")
-    firmware_version: Optional[StrictStr] = Field(default=None, description="Text FirmwareVersion value in format A.B (e.g. 5.19)", alias="FirmwareVersion")
-    applications: List[RfidApplication] = Field(description="List of containers to store information about the involved applications of electronic document", alias="Applications")
-    access_controls: List[RfidAccessControlInfo] = Field(description="List of containers to store information about the supported procedures of authentication and secure data access within the context of the session", alias="AccessControls")
-    card_properties: RfidCardPropertiesExt = Field(alias="CardProperties")
-    ext_le_support: RFIDErrorCodes = Field(alias="ExtLeSupport")
-    process_time: Union[StrictFloat, StrictInt] = Field(description="Time of processing, milliseconds", alias="ProcessTime")
-    root_files: List[Any] = Field(description="List of containers to store information about the read files of the root Master File", alias="RootFiles")
-    total_bytes_sent: Union[StrictFloat, StrictInt] = Field(description="Total number of bytes transmitted to the RFID-chip during the whole session", alias="TotalBytesSent")
-    total_bytes_received: Union[StrictFloat, StrictInt] = Field(description="Total number of bytes received from the RFID-chip during the whole session", alias="TotalBytesReceived")
-    session_key: RfidAccessKey = Field(alias="Session_key")
-    session_terminal: RfidTerminal = Field(alias="Session_terminal")
-    session_procedure: RfidAuthenticationProcedureType = Field(alias="Session_procedure")
-    security_objects: List[RfidSecurityObject] = Field(description="List of containers to store information about the detected document security objects", alias="SecurityObjects")
-    status: Optional[CheckResult] = Field(default=None, alias="Status")
-    __properties: ClassVar[List[str]] = ["VirtualMode", "SDKVersion", "DriverVersion", "FirmwareVersion", "Applications", "AccessControls", "CardProperties", "ExtLeSupport", "ProcessTime", "RootFiles", "TotalBytesSent", "TotalBytesReceived", "Session_key", "Session_terminal", "Session_procedure", "SecurityObjects", "Status"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RfidSessionData from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of each item in applications (list)
-        _items = []
-        if self.applications:
-            for _item_applications in self.applications:
-                if _item_applications:
-                    _items.append(_item_applications.to_dict())
-            _dict['Applications'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in access_controls (list)
-        _items = []
-        if self.access_controls:
-            for _item_access_controls in self.access_controls:
-                if _item_access_controls:
-                    _items.append(_item_access_controls.to_dict())
-            _dict['AccessControls'] = _items
-        # override the default output from pydantic by calling `to_dict()` of card_properties
-        if self.card_properties:
-            _dict['CardProperties'] = self.card_properties.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of session_key
-        if self.session_key:
-            _dict['Session_key'] = self.session_key.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of session_terminal
-        if self.session_terminal:
-            _dict['Session_terminal'] = self.session_terminal.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in security_objects (list)
-        _items = []
-        if self.security_objects:
-            for _item_security_objects in self.security_objects:
-                if _item_security_objects:
-                    _items.append(_item_security_objects.to_dict())
-            _dict['SecurityObjects'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidSessionData from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "VirtualMode": obj.get("VirtualMode"),
-            "SDKVersion": obj.get("SDKVersion"),
-            "DriverVersion": obj.get("DriverVersion"),
-            "FirmwareVersion": obj.get("FirmwareVersion"),
-            "Applications": [RfidApplication.from_dict(_item) for _item in obj["Applications"]] if obj.get("Applications") is not None else None,
-            "AccessControls": [RfidAccessControlInfo.from_dict(_item) for _item in obj["AccessControls"]] if obj.get("AccessControls") is not None else None,
-            "CardProperties": RfidCardPropertiesExt.from_dict(obj["CardProperties"]) if obj.get("CardProperties") is not None else None,
-            "ExtLeSupport": obj.get("ExtLeSupport"),
-            "ProcessTime": obj.get("ProcessTime"),
-            "RootFiles": obj.get("RootFiles"),
-            "TotalBytesSent": obj.get("TotalBytesSent"),
-            "TotalBytesReceived": obj.get("TotalBytesReceived"),
-            "Session_key": RfidAccessKey.from_dict(obj["Session_key"]) if obj.get("Session_key") is not None else None,
-            "Session_terminal": RfidTerminal.from_dict(obj["Session_terminal"]) if obj.get("Session_terminal") is not None else None,
-            "Session_procedure": obj.get("Session_procedure"),
-            "SecurityObjects": [RfidSecurityObject.from_dict(_item) for _item in obj["SecurityObjects"]] if obj.get("SecurityObjects") is not None else None,
-            "Status": obj.get("Status")
-        })
-        return _obj
-
-

regula/documentreader/webclient/gen/models/rfid_signer_info_ex.py

@@ -1,133 +0,0 @@
-# coding: utf-8
-
-"""
-    Generated by: https://openapi-generator.tech
-"""
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Union
-from regula.documentreader.webclient.gen.models.parsing_notification_codes import ParsingNotificationCodes
-from regula.documentreader.webclient.gen.models.rfid_attribute_data import RfidAttributeData
-from regula.documentreader.webclient.gen.models.rfid_certificate_ex import RfidCertificateEx
-from regula.documentreader.webclient.gen.models.rfid_distinguished_name import RfidDistinguishedName
-from regula.documentreader.webclient.gen.models.rfid_error_codes import RFIDErrorCodes
-from regula.documentreader.webclient.gen.models.trf_ft_bytes import TrfFtBytes
-from typing import Optional, Set
-from typing_extensions import Self
-
-class RfidSignerInfoEx(BaseModel):
-    """
-    Structure is used to describe the contents of a single copy of digital signature of the document security object and the results of its check within the context of the communication session with electronic document
-    """ # noqa: E501
-    version: Union[StrictFloat, StrictInt] = Field(description="Version of SignerInfo ASN.1 structure", alias="Version")
-    issuer: RfidDistinguishedName = Field(alias="Issuer")
-    serial_number: TrfFtBytes = Field(alias="SerialNumber")
-    subject_key_identifier: TrfFtBytes = Field(alias="SubjectKeyIdentifier")
-    digest_algorithm: StrictStr = Field(description="Hash algorithm identifier (OID) for digital signature generation", alias="DigestAlgorithm")
-    signed_attributes: List[RfidAttributeData] = Field(description="List of the signed attributes", alias="SignedAttributes")
-    signature_algorithm: StrictStr = Field(description="Digital signature algorithm identifier (OID)", alias="SignatureAlgorithm")
-    signature: TrfFtBytes = Field(alias="Signature")
-    pa_status: RFIDErrorCodes = Field(alias="PA_Status")
-    certificate_chain: List[RfidCertificateEx] = Field(description="Certificate chain, used for the digital signature verification.", alias="CertificateChain")
-    data_to_hash: StrictStr = Field(description="Binary data array used to calculate the hash value for digital signature verification. Base64 encoded.", alias="DataToHash")
-    notifications: List[ParsingNotificationCodes] = Field(alias="Notifications")
-    __properties: ClassVar[List[str]] = ["Version", "Issuer", "SerialNumber", "SubjectKeyIdentifier", "DigestAlgorithm", "SignedAttributes", "SignatureAlgorithm", "Signature", "PA_Status", "CertificateChain", "DataToHash", "Notifications"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RfidSignerInfoEx from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of issuer
-        if self.issuer:
-            _dict['Issuer'] = self.issuer.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of serial_number
-        if self.serial_number:
-            _dict['SerialNumber'] = self.serial_number.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of subject_key_identifier
-        if self.subject_key_identifier:
-            _dict['SubjectKeyIdentifier'] = self.subject_key_identifier.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in signed_attributes (list)
-        _items = []
-        if self.signed_attributes:
-            for _item_signed_attributes in self.signed_attributes:
-                if _item_signed_attributes:
-                    _items.append(_item_signed_attributes.to_dict())
-            _dict['SignedAttributes'] = _items
-        # override the default output from pydantic by calling `to_dict()` of signature
-        if self.signature:
-            _dict['Signature'] = self.signature.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in certificate_chain (list)
-        _items = []
-        if self.certificate_chain:
-            for _item_certificate_chain in self.certificate_chain:
-                if _item_certificate_chain:
-                    _items.append(_item_certificate_chain.to_dict())
-            _dict['CertificateChain'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RfidSignerInfoEx from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "Version": obj.get("Version"),
-            "Issuer": RfidDistinguishedName.from_dict(obj["Issuer"]) if obj.get("Issuer") is not None else None,
-            "SerialNumber": TrfFtBytes.from_dict(obj["SerialNumber"]) if obj.get("SerialNumber") is not None else None,
-            "SubjectKeyIdentifier": TrfFtBytes.from_dict(obj["SubjectKeyIdentifier"]) if obj.get("SubjectKeyIdentifier") is not None else None,
-            "DigestAlgorithm": obj.get("DigestAlgorithm"),
-            "SignedAttributes": [RfidAttributeData.from_dict(_item) for _item in obj["SignedAttributes"]] if obj.get("SignedAttributes") is not None else None,
-            "SignatureAlgorithm": obj.get("SignatureAlgorithm"),
-            "Signature": TrfFtBytes.from_dict(obj["Signature"]) if obj.get("Signature") is not None else None,
-            "PA_Status": obj.get("PA_Status"),
-            "CertificateChain": [RfidCertificateEx.from_dict(_item) for _item in obj["CertificateChain"]] if obj.get("CertificateChain") is not None else None,
-            "DataToHash": obj.get("DataToHash"),
-            "Notifications": obj.get("Notifications")
-        })
-        return _obj
-
-