regula-documentreader-webclient 8.5.617.dev0__py3-none-any.whl → 9.1.645.dev0__py3-none-any.whl

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

@@ -65,7 +65,7 @@ class StatusItem(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of status
-        if self.status:
+        if self.status and isinstance(self.status, Status):
             _dict['Status'] = self.status.to_dict()
         return _dict
 

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

@@ -67,7 +67,7 @@ class StatusResult(ResultItem):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of status
-        if self.status:
+        if self.status and isinstance(self.status, Status):
             _dict['Status'] = self.status.to_dict()
         return _dict
 

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

@@ -85,23 +85,23 @@ class StringItem(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of error_position
-        if self.error_position:
+        if self.error_position and isinstance(self.error_position, ErrorCoordinates):
             _dict['ErrorPOSITION'] = self.error_position.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
         _items = []
         if self.fields:
             for _item_fields in self.fields:
-                if _item_fields:
+                if _item_fields and hasattr(_item_fields, "to_dict"):
                     _items.append(_item_fields.to_dict())
             _dict['Fields'] = _items
         # override the default output from pydantic by calling `to_dict()` of string_borders
-        if self.string_borders:
+        if self.string_borders and isinstance(self.string_borders, RectangleCoordinates):
             _dict['StringBorders'] = self.string_borders.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in symbols_estimations (list)
         _items = []
         if self.symbols_estimations:
             for _item_symbols_estimations in self.symbols_estimations:
-                if _item_symbols_estimations:
+                if _item_symbols_estimations and hasattr(_item_symbols_estimations, "to_dict"):
                     _items.append(_item_symbols_estimations.to_dict())
             _dict['SymbolsEstimations'] = _items
         return _dict

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

@@ -72,7 +72,7 @@ class StringRecognitionResult(BaseModel):
         _items = []
         if self.string_result:
             for _item_string_result in self.string_result:
-                if _item_string_result:
+                if _item_string_result and hasattr(_item_string_result, "to_dict"):
                     _items.append(_item_string_result.to_dict())
             _dict['StringResult'] = _items
         return _dict

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

@@ -81,7 +81,7 @@ class SymbolEstimationItem(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of symbol_bounds
-        if self.symbol_bounds:
+        if self.symbol_bounds and isinstance(self.symbol_bounds, RectangleCoordinates):
             _dict['SymbolBounds'] = self.symbol_bounds.to_dict()
         return _dict
 

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

@@ -70,13 +70,13 @@ class SymbolRecognitionResult(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of symbol_rect
-        if self.symbol_rect:
+        if self.symbol_rect and isinstance(self.symbol_rect, RectangleCoordinates):
             _dict['SymbolRect'] = self.symbol_rect.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in list_of_candidates (list)
         _items = []
         if self.list_of_candidates:
             for _item_list_of_candidates in self.list_of_candidates:
-                if _item_list_of_candidates:
+                if _item_list_of_candidates and hasattr(_item_list_of_candidates, "to_dict"):
                     _items.append(_item_list_of_candidates.to_dict())
             _dict['ListOfCandidates'] = _items
         return _dict

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

@@ -67,13 +67,13 @@ class TDocBinaryInfo(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of rfid_binary_data
-        if self.rfid_binary_data:
+        if self.rfid_binary_data and isinstance(self.rfid_binary_data, BinaryData):
             _dict['RFID_BINARY_DATA'] = self.rfid_binary_data.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in rfid_raw_data (list)
         _items = []
         if self.rfid_raw_data:
             for _item_rfid_raw_data in self.rfid_raw_data:
-                if _item_rfid_raw_data:
+                if _item_rfid_raw_data and hasattr(_item_rfid_raw_data, "to_dict"):
                     _items.append(_item_rfid_raw_data.to_dict())
             _dict['RFID_RAW_DATA'] = _items
         return _dict

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

@@ -65,7 +65,7 @@ class TDocBinaryInfoItem(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of t_doc_binary_info
-        if self.t_doc_binary_info:
+        if self.t_doc_binary_info and isinstance(self.t_doc_binary_info, TDocBinaryInfo):
             _dict['TDocBinaryInfo'] = self.t_doc_binary_info.to_dict()
         return _dict
 

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

@@ -68,7 +68,7 @@ class TOriginalRFIDGraphicsInfo(BaseModel):
         _items = []
         if self.rfid_original_graph_data:
             for _item_rfid_original_graph_data in self.rfid_original_graph_data:
-                if _item_rfid_original_graph_data:
+                if _item_rfid_original_graph_data and hasattr(_item_rfid_original_graph_data, "to_dict"):
                     _items.append(_item_rfid_original_graph_data.to_dict())
             _dict['RFID_ORIGINAL_GRAPH_DATA'] = _items
         return _dict

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

@@ -65,7 +65,7 @@ class TOriginalRFIDGraphicsInfoItem(BaseModel):
             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:
+        if self.t_original_rfid_graphics_info and isinstance(self.t_original_rfid_graphics_info, TOriginalRFIDGraphicsInfo):
             _dict['TOriginalRFIDGraphicsInfo'] = self.t_original_rfid_graphics_info.to_dict()
         return _dict
 

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

@@ -75,14 +75,14 @@ class Text(BaseModel):
         _items = []
         if self.field_list:
             for _item_field_list in self.field_list:
-                if _item_field_list:
+                if _item_field_list and hasattr(_item_field_list, "to_dict"):
                     _items.append(_item_field_list.to_dict())
             _dict['fieldList'] = _items
         # override the default output from pydantic by calling `to_dict()` of each item in available_source_list (list)
         _items = []
         if self.available_source_list:
             for _item_available_source_list in self.available_source_list:
-                if _item_available_source_list:
+                if _item_available_source_list and hasattr(_item_available_source_list, "to_dict"):
                     _items.append(_item_available_source_list.to_dict())
             _dict['availableSourceList'] = _items
         return _dict

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

@@ -67,7 +67,7 @@ class TextDataResult(ResultItem):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of doc_visual_extended_info
-        if self.doc_visual_extended_info:
+        if self.doc_visual_extended_info and isinstance(self.doc_visual_extended_info, DocVisualExtendedInfo):
             _dict['DocVisualExtendedInfo'] = self.doc_visual_extended_info.to_dict()
         return _dict
 

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

@@ -83,21 +83,21 @@ class TextField(BaseModel):
         _items = []
         if self.value_list:
             for _item_value_list in self.value_list:
-                if _item_value_list:
+                if _item_value_list and hasattr(_item_value_list, "to_dict"):
                     _items.append(_item_value_list.to_dict())
             _dict['valueList'] = _items
         # override the default output from pydantic by calling `to_dict()` of each item in validity_list (list)
         _items = []
         if self.validity_list:
             for _item_validity_list in self.validity_list:
-                if _item_validity_list:
+                if _item_validity_list and hasattr(_item_validity_list, "to_dict"):
                     _items.append(_item_validity_list.to_dict())
             _dict['validityList'] = _items
         # override the default output from pydantic by calling `to_dict()` of each item in comparison_list (list)
         _items = []
         if self.comparison_list:
             for _item_comparison_list in self.comparison_list:
-                if _item_comparison_list:
+                if _item_comparison_list and hasattr(_item_comparison_list, "to_dict"):
                     _items.append(_item_comparison_list.to_dict())
             _dict['comparisonList'] = _items
         return _dict

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

@@ -667,6 +667,9 @@ class TextFieldType(int, Enum):
     FT_NATIONALITY_CODE_ALPHA2 = 697
     FT_FIRST_ISSUE_DATE_CHECK_DIGIT = 698
     FT_FIRST_ISSUE_DATE_CHECKSUM = 699
+    FT_COMMERCIAL_INDICATOR = 701
+    FT_NON_DOMICILED_INDICATOR = 702
+    FT_JURISDICTION_SPECIFIC_DATA = 703
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:

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

@@ -82,14 +82,14 @@ class TextFieldValue(BaseModel):
         _items = []
         if self.original_symbols:
             for _item_original_symbols in self.original_symbols:
-                if _item_original_symbols:
+                if _item_original_symbols and hasattr(_item_original_symbols, "to_dict"):
                     _items.append(_item_original_symbols.to_dict())
             _dict['originalSymbols'] = _items
         # override the default output from pydantic by calling `to_dict()` of field_rect
-        if self.field_rect:
+        if self.field_rect and isinstance(self.field_rect, RectangleCoordinates):
             _dict['fieldRect'] = self.field_rect.to_dict()
         # override the default output from pydantic by calling `to_dict()` of rfid_origin
-        if self.rfid_origin:
+        if self.rfid_origin and isinstance(self.rfid_origin, RfidOrigin):
             _dict['rfidOrigin'] = self.rfid_origin.to_dict()
         return _dict
 

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

@@ -65,7 +65,7 @@ class TextItem(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of text
-        if self.text:
+        if self.text and isinstance(self.text, Text):
             _dict['Text'] = self.text.to_dict()
         return _dict
 

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

@@ -67,7 +67,7 @@ class TextResult(ResultItem):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of text
-        if self.text:
+        if self.text and isinstance(self.text, Text):
             _dict['Text'] = self.text.to_dict()
         return _dict
 

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

@@ -65,7 +65,7 @@ class TransactionImage(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of image
-        if self.image:
+        if self.image and isinstance(self.image, ImagesFieldValue):
             _dict['image'] = self.image.to_dict()
         return _dict
 

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

@@ -72,7 +72,7 @@ class TransactionInfo(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of documents_database
-        if self.documents_database:
+        if self.documents_database and isinstance(self.documents_database, DocumentsDatabase):
             _dict['DocumentsDatabase'] = self.documents_database.to_dict()
         return _dict
 

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

@@ -70,10 +70,10 @@ class TransactionProcessGetResponse(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of out_data
-        if self.out_data:
+        if self.out_data and isinstance(self.out_data, OutData):
             _dict['outData'] = self.out_data.to_dict()
         # override the default output from pydantic by calling `to_dict()` of in_data
-        if self.in_data:
+        if self.in_data and isinstance(self.in_data, InData):
             _dict['inData'] = self.in_data.to_dict()
         return _dict
 

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

@@ -78,20 +78,20 @@ class TransactionProcessRequest(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of process_param
-        if self.process_param:
+        if self.process_param and isinstance(self.process_param, ProcessParams):
             _dict['processParam'] = self.process_param.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in list (list)
         _items = []
         if self.list:
             for _item_list in self.list:
-                if _item_list:
+                if _item_list and hasattr(_item_list, "to_dict"):
                     _items.append(_item_list.to_dict())
             _dict['List'] = _items
         # override the default output from pydantic by calling `to_dict()` of container_list
-        if self.container_list:
+        if self.container_list and isinstance(self.container_list, ContainerList):
             _dict['ContainerList'] = self.container_list.to_dict()
         # override the default output from pydantic by calling `to_dict()` of system_info
-        if self.system_info:
+        if self.system_info and isinstance(self.system_info, ProcessSystemInfo):
             _dict['systemInfo'] = self.system_info.to_dict()
         return _dict
 

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

@@ -70,10 +70,10 @@ class TransactionProcessResult(BaseModel):
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of out_data
-        if self.out_data:
+        if self.out_data and isinstance(self.out_data, OutData):
             _dict['outData'] = self.out_data.to_dict()
         # override the default output from pydantic by calling `to_dict()` of in_data
-        if self.in_data:
+        if self.in_data and isinstance(self.in_data, InData):
             _dict['inData'] = self.in_data.to_dict()
         return _dict
 

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

@@ -22,7 +22,7 @@ class TrfFtString(BaseModel):
     type: SkipValidation[Optional[int]] = Field(alias="Type", default=None)
     status: SkipValidation[Optional[int]] = Field(alias="Status", default=None, description="Result of logical analysis of compliance of the contents of the field with the requirements of the specification")
     format: SkipValidation[Optional[str]] = Field(alias="Format", default=None, description="Mask of format of text information (for example, «YYMMDD» for date of birth)")
-    data: SkipValidation[str] = Field(alias="Data", description="Numeric value.")
+    data: SkipValidation[Optional[str]] = Field(alias="Data", default=None, description="Numeric value.")
     __properties: ClassVar[List[str]] = ["Type", "Status", "Format", "Data"]
 
     model_config = ConfigDict(

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

@@ -0,0 +1,90 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class VDItem(BaseModel):
+    """
+    VDItem
+    """ # noqa: E501
+    adm: SkipValidation[Optional[str]] = Field(alias="adm", default=None)
+    ctr: SkipValidation[Optional[str]] = Field(alias="ctr", default=None)
+    dvc: SkipValidation[Optional[str]] = Field(alias="dvc", default=None)
+    lot: SkipValidation[Optional[str]] = Field(alias="lot", default=None)
+    seq: SkipValidation[Optional[int]] = Field(alias="seq", default=None)
+    __properties: ClassVar[List[str]] = ["adm", "ctr", "dvc", "lot", "seq"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 VDItem 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 VDItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "adm": obj.get("adm"),
+            "ctr": obj.get("ctr"),
+            "dvc": obj.get("dvc"),
+            "lot": obj.get("lot"),
+            "seq": obj.get("seq")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,126 @@
+# 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, Optional
+from regula.documentreader.webclient.gen.models.doc_feature import DocFeature
+from regula.documentreader.webclient.gen.models.rfid_certificate_ex import RfidCertificateEx
+from regula.documentreader.webclient.gen.models.trf_ft_bytes import TrfFtBytes
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class VDSData(BaseModel):
+    """
+    VDSData
+    """ # noqa: E501
+    certificate: SkipValidation[Optional[str]] = Field(alias="Certificate", default=None)
+    certificate_chain: SkipValidation[Optional[List[RfidCertificateEx]]] = Field(alias="CertificateChain", default=None)
+    doc_features: SkipValidation[Optional[List[DocFeature]]] = Field(alias="DocFeatures", default=None)
+    doc_issue_date: SkipValidation[Optional[str]] = Field(alias="DocIssueDate", default=None)
+    doc_type: SkipValidation[Optional[int]] = Field(alias="DocType", default=None)
+    feature_ref: SkipValidation[Optional[int]] = Field(alias="FeatureRef", default=None)
+    issuing_country: SkipValidation[Optional[str]] = Field(alias="IssuingCountry", default=None)
+    notifications: SkipValidation[Optional[List[int]]] = Field(alias="Notifications", default=None)
+    signature: SkipValidation[Optional[TrfFtBytes]] = Field(alias="Signature", default=None)
+    signature_date: SkipValidation[Optional[str]] = Field(alias="SignatureDate", default=None)
+    signer: SkipValidation[Optional[str]] = Field(alias="Signer", default=None)
+    type: SkipValidation[Optional[int]] = Field(alias="Type", default=None)
+    version: SkipValidation[Optional[int]] = Field(alias="Version", default=None)
+    __properties: ClassVar[List[str]] = ["Certificate", "CertificateChain", "DocFeatures", "DocIssueDate", "DocType", "FeatureRef", "IssuingCountry", "Notifications", "Signature", "SignatureDate", "Signer", "Type", "Version"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 VDSData 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 certificate_chain (list)
+        _items = []
+        if self.certificate_chain:
+            for _item_certificate_chain in self.certificate_chain:
+                if _item_certificate_chain and hasattr(_item_certificate_chain, "to_dict"):
+                    _items.append(_item_certificate_chain.to_dict())
+            _dict['CertificateChain'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in doc_features (list)
+        _items = []
+        if self.doc_features:
+            for _item_doc_features in self.doc_features:
+                if _item_doc_features and hasattr(_item_doc_features, "to_dict"):
+                    _items.append(_item_doc_features.to_dict())
+            _dict['DocFeatures'] = _items
+        # override the default output from pydantic by calling `to_dict()` of signature
+        if self.signature and isinstance(self.signature, TrfFtBytes):
+            _dict['Signature'] = self.signature.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of VDSData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "Certificate": obj.get("Certificate"),
+            "CertificateChain": [RfidCertificateEx.from_dict(_item) for _item in obj.get("CertificateChain", []) if RfidCertificateEx.from_dict(_item) is not None],
+            "DocFeatures": [DocFeature.from_dict(_item) for _item in obj.get("DocFeatures", []) if DocFeature.from_dict(_item) is not None],
+            "DocIssueDate": obj.get("DocIssueDate"),
+            "DocType": obj.get("DocType"),
+            "FeatureRef": obj.get("FeatureRef"),
+            "IssuingCountry": obj.get("IssuingCountry"),
+            "Notifications": obj.get("Notifications"),
+            "Signature": TrfFtBytes.from_dict(obj["Signature"]) if obj.get("Signature") is not None else None,
+            "SignatureDate": obj.get("SignatureDate"),
+            "Signer": obj.get("Signer"),
+            "Type": obj.get("Type"),
+            "Version": obj.get("Version")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,86 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from regula.documentreader.webclient.gen.models.vds_data import VDSData
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic import SkipValidation, Field
+
+class VDSDataItem(BaseModel):
+    """
+    VDSDataItem
+    """ # noqa: E501
+    dft_vds: SkipValidation[VDSData] = Field(alias="dftVDS")
+    __properties: ClassVar[List[str]] = ["dftVDS"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        arbitrary_types_allowed=True,
+        use_enum_values=True
+    )
+
+
+    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 VDSDataItem 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 dft_vds
+        if self.dft_vds and isinstance(self.dft_vds, VDSData):
+            _dict['dftVDS'] = self.dft_vds.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of VDSDataItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dftVDS": VDSData.from_dict(obj["dftVDS"]) if obj.get("dftVDS") is not None else None
+        })
+        return _obj
+
+