regula-documentreader-webclient 8.1.349rc0__py3-none-any.whl → 8.1.351.dev0__py3-none-any.whl

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

@@ -0,0 +1,81 @@
+# 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

@@ -0,0 +1,81 @@
+# 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

@@ -0,0 +1,96 @@
+# 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

@@ -0,0 +1,150 @@
+# 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

@@ -0,0 +1,133 @@
+# 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
+
+

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

@@ -0,0 +1,84 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Union
+from regula.documentreader.webclient.gen.models.rfid_terminal_type import RfidTerminalType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RfidTerminal(BaseModel):
+    """
+    Structure is used to describe the terminal type within the context of the communication session with electronic document
+    """ # noqa: E501
+    term_type: RfidTerminalType = Field(alias="TermType")
+    auth_req: Union[StrictFloat, StrictInt] = Field(description="Declared (set) combination of flags of access rights to the functionality of the document (combination of eRfidTerminalAuthorizationRequirement values)", alias="AuthReq")
+    auth_req2: Union[StrictFloat, StrictInt] = Field(description="Declared (set) combination of flags of access rights to the functionality of the document (combination of RfidTerminalAuthorizationRequirement values)", alias="AuthReq2")
+    __properties: ClassVar[List[str]] = ["TermType", "AuthReq", "AuthReq2"]
+
+    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 RfidTerminal 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 RfidTerminal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "TermType": obj.get("TermType"),
+            "AuthReq": obj.get("AuthReq"),
+            "AuthReq2": obj.get("AuthReq2")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,32 @@
+# 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 RfidTerminalType(int, Enum):
+    """
+    Enumeration contains a set of constants that define the type of terminal within the context of the communication session with electronic document
+    """
+
+    """
+    allowed enum values
+    """
+    UNDEFINED = 0
+    INSPECTION_SYSTEM = 1
+    AUTHENTICATION_TERMINAL = 2
+    SIGNATURE_TERMINAL = 3
+    UNAUTHENTICATED_TERMINAL = 4
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of RfidTerminalType from a JSON string"""
+        return cls(json.loads(json_str))
+
+