rxfoundry.clients.swifty-api 0.0.680__py3-none-any.whl → 0.1.1005__py3-none-any.whl

rxfoundry/clients/swifty_api/models/patient_address_data.py

@@ -18,8 +18,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,13 +28,24 @@ class PatientAddressData(BaseModel):
     """
     PatientAddressData
     """ # noqa: E501
-    address_line_one: Optional[StrictStr] = Field(default=None, description="The first line of the address")
-    address_line_two: Optional[StrictStr] = Field(default=None, description="The second line of the address")
-    city: Optional[StrictStr] = Field(default=None, description="The city")
-    state_province: Optional[StrictStr] = Field(default=None, description="The state or province using the two alphabetic character abbreviation (e.g. TX, CA, NY)")
-    postal_code: Optional[StrictStr] = Field(default=None, description="The postal code in 5 digit format")
-    country_code: Optional[StrictStr] = Field(default=None, description="The country code using the two alphabetic character abbreviation (e.g. US, CA, GB)")
-    __properties: ClassVar[List[str]] = ["address_line_one", "address_line_two", "city", "state_province", "postal_code", "country_code"]
+    object_type: StrictStr = Field(description="The discriminator used to determine the type of the object.  This is required for the discriminator to work correctly")
+    uuid: Optional[StrictStr] = Field(default=None, description="The uuid of the address for updates and deletes.  If passed in on create, then it is ignored.")
+    address_line_one: Annotated[str, Field(strict=True, max_length=255)] = Field(description="The first line of the address")
+    address_line_two: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The second line of the address")
+    city: Annotated[str, Field(strict=True, max_length=50)] = Field(description="The city")
+    state_province: Annotated[str, Field(strict=True, max_length=50)] = Field(description="The state or province using the two alphabetic character abbreviation (e.g. TX, CA, NY)")
+    postal_code: Annotated[str, Field(strict=True, max_length=50)] = Field(description="The postal code in 5 digit format")
+    country_code: Annotated[str, Field(strict=True, max_length=50)] = Field(description="The country code using the two alphabetic character abbreviation (e.g. US, CA, GB)")
+    latitude: Optional[Annotated[str, Field(strict=True, max_length=50)]] = Field(default=None, description="The latitude of the address")
+    longitude: Optional[Annotated[str, Field(strict=True, max_length=50)]] = Field(default=None, description="The longitude of the address")
+    __properties: ClassVar[List[str]] = ["object_type", "uuid", "address_line_one", "address_line_two", "city", "state_province", "postal_code", "country_code", "latitude", "longitude"]
+
+    @field_validator('object_type')
+    def object_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['address']):
+            raise ValueError("must be one of enum values ('address')")
+        return value
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -86,12 +98,16 @@ class PatientAddressData(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "uuid": obj.get("uuid"),
             "address_line_one": obj.get("address_line_one"),
             "address_line_two": obj.get("address_line_two"),
             "city": obj.get("city"),
             "state_province": obj.get("state_province"),
             "postal_code": obj.get("postal_code"),
-            "country_code": obj.get("country_code")
+            "country_code": obj.get("country_code"),
+            "latitude": obj.get("latitude"),
+            "longitude": obj.get("longitude")
         })
         return _obj
 

rxfoundry/clients/swifty_api/models/patient_allergy.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    SwiftyRX API
+
+    API for the SwiftyRX Backend 
+
+    The version of the OpenAPI document: 0.1.DEV-0
+    Contact: paul.tindall@rxfoundry.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from rxfoundry.clients.swifty_api.models.code import Code
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PatientAllergy(BaseModel):
+    """
+    PatientAllergy
+    """ # noqa: E501
+    allergy: Optional[Code] = None
+    __properties: ClassVar[List[str]] = ["allergy"]
+
+    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 PatientAllergy 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 allergy
+        if self.allergy:
+            _dict['allergy'] = self.allergy.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatientAllergy from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "allergy": Code.from_dict(obj["allergy"]) if obj.get("allergy") is not None else None
+        })
+        return _obj
+
+

rxfoundry/clients/swifty_api/models/patient_condition.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    SwiftyRX API
+
+    API for the SwiftyRX Backend 
+
+    The version of the OpenAPI document: 0.1.DEV-0
+    Contact: paul.tindall@rxfoundry.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from rxfoundry.clients.swifty_api.models.code import Code
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PatientCondition(BaseModel):
+    """
+    PatientCondition
+    """ # noqa: E501
+    condition: Optional[Code] = None
+    __properties: ClassVar[List[str]] = ["condition"]
+
+    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 PatientCondition 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 condition
+        if self.condition:
+            _dict['condition'] = self.condition.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatientCondition from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "condition": Code.from_dict(obj["condition"]) if obj.get("condition") is not None else None
+        })
+        return _obj
+
+

rxfoundry/clients/swifty_api/models/patient_data.py

@@ -28,6 +28,7 @@ class PatientData(BaseModel):
     """
     A patient's data that is used to manage a patient record within Swifty
     """ # noqa: E501
+    object_type: StrictStr = Field(description="The discriminator used to determine the type of the object.  This is required for the discriminator to work correctly.")
     last_name: StrictStr = Field(description="The patient's last name")
     first_name: StrictStr = Field(description="The patient's first name")
     middle_name: Optional[StrictStr] = Field(default=None, description="The patient's middle name")
@@ -38,7 +39,15 @@ class PatientData(BaseModel):
     primary_phone: StrictStr = Field(description="The patient's primary phone number.  This could be a mobile phone number or a landline phone number.  The format is a string based upon US numbers.  For example, 555-555-5555 or (555) 555-5555")
     alternate_phone: Optional[StrictStr] = Field(default=None, description="An alternate phone number for the patient.  Similar rules apply here as in the primary_phone field")
     email: StrictStr = Field(description="The patient's email address")
-    __properties: ClassVar[List[str]] = ["last_name", "first_name", "middle_name", "suffix", "prefix", "gender_assigned_at_birth", "date_of_birth", "primary_phone", "alternate_phone", "email"]
+    preferred_language: Optional[StrictStr] = Field(default='EN', description="The patient's preferred language using the two alphabetic character abbreviation (e.g. EN, FR, ES).  Must be a value in the Languages Codes Type.")
+    __properties: ClassVar[List[str]] = ["object_type", "last_name", "first_name", "middle_name", "suffix", "prefix", "gender_assigned_at_birth", "date_of_birth", "primary_phone", "alternate_phone", "email", "preferred_language"]
+
+    @field_validator('object_type')
+    def object_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['patient']):
+            raise ValueError("must be one of enum values ('patient')")
+        return value
 
     @field_validator('gender_assigned_at_birth')
     def gender_assigned_at_birth_validate_enum(cls, value):
@@ -98,6 +107,7 @@ class PatientData(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
             "last_name": obj.get("last_name"),
             "first_name": obj.get("first_name"),
             "middle_name": obj.get("middle_name"),
@@ -107,7 +117,8 @@ class PatientData(BaseModel):
             "date_of_birth": obj.get("date_of_birth"),
             "primary_phone": obj.get("primary_phone"),
             "alternate_phone": obj.get("alternate_phone"),
-            "email": obj.get("email")
+            "email": obj.get("email"),
+            "preferred_language": obj.get("preferred_language") if obj.get("preferred_language") is not None else 'EN'
         })
         return _obj
 

rxfoundry/clients/swifty_api/models/patient_external_identifier.py

@@ -18,8 +18,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr
+from pydantic import BaseModel, ConfigDict, Field
 from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,10 +28,10 @@ class PatientExternalIdentifier(BaseModel):
     """
     PatientExternalIdentifier
     """ # noqa: E501
-    external_id: Optional[StrictStr] = None
-    external_system_slug: Optional[StrictStr] = None
-    external_email: Optional[StrictStr] = None
-    external_mobile_phone: Optional[StrictStr] = None
+    external_id: Annotated[str, Field(strict=True, max_length=255)] = Field(description="The identifier for the patient in the context of the external system")
+    external_system_slug: Annotated[str, Field(strict=True, max_length=255)] = Field(description="The identifier for the external system that is managing the patient record.  Not the same as the virtual pharamcy slug.")
+    external_email: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The email address for the patient in the context of the external system")
+    external_mobile_phone: Optional[Annotated[str, Field(strict=True, max_length=25)]] = Field(default=None, description="The mobile phone number for the patient in the context of the external system")
     __properties: ClassVar[List[str]] = ["external_id", "external_system_slug", "external_email", "external_mobile_phone"]
 
     model_config = ConfigDict(

rxfoundry/clients/swifty_api/models/patient_health_profile_data.py

@@ -0,0 +1,127 @@
+# coding: utf-8
+
+"""
+    SwiftyRX API
+
+    API for the SwiftyRX Backend 
+
+    The version of the OpenAPI document: 0.1.DEV-0
+    Contact: paul.tindall@rxfoundry.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from rxfoundry.clients.swifty_api.models.code import Code
+from rxfoundry.clients.swifty_api.models.medication_ref import MedicationRef
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PatientHealthProfileData(BaseModel):
+    """
+    The latest patient health profile as provided by an external system (e.g. patient portal, emr).  This data should include all current information and the backend will determine what to add or remove.  Also, the only action that is operated on is 'updated'.
+    """ # noqa: E501
+    object_type: Optional[StrictStr] = Field(default=None, description="The discriminator used to determine the type of the object.  This is required for the discriminator to work correctly.")
+    allergies: Optional[List[Code]] = None
+    conditions: Optional[List[Code]] = None
+    medications: Optional[List[MedicationRef]] = None
+    __properties: ClassVar[List[str]] = ["object_type", "allergies", "conditions", "medications"]
+
+    @field_validator('object_type')
+    def object_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['health_profile']):
+            raise ValueError("must be one of enum values ('health_profile')")
+        return value
+
+    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 PatientHealthProfileData 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 allergies (list)
+        _items = []
+        if self.allergies:
+            for _item_allergies in self.allergies:
+                if _item_allergies:
+                    _items.append(_item_allergies.to_dict())
+            _dict['allergies'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in conditions (list)
+        _items = []
+        if self.conditions:
+            for _item_conditions in self.conditions:
+                if _item_conditions:
+                    _items.append(_item_conditions.to_dict())
+            _dict['conditions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in medications (list)
+        _items = []
+        if self.medications:
+            for _item_medications in self.medications:
+                if _item_medications:
+                    _items.append(_item_medications.to_dict())
+            _dict['medications'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatientHealthProfileData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "allergies": [Code.from_dict(_item) for _item in obj["allergies"]] if obj.get("allergies") is not None else None,
+            "conditions": [Code.from_dict(_item) for _item in obj["conditions"]] if obj.get("conditions") is not None else None,
+            "medications": [MedicationRef.from_dict(_item) for _item in obj["medications"]] if obj.get("medications") is not None else None
+        })
+        return _obj
+
+

rxfoundry/clients/swifty_api/models/patient_insurance.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    SwiftyRX API
+
+    API for the SwiftyRX Backend 
+
+    The version of the OpenAPI document: 0.1.DEV-0
+    Contact: paul.tindall@rxfoundry.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+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, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PatientInsurance(BaseModel):
+    """
+    PatientInsurance
+    """ # noqa: E501
+    uuid: Optional[StrictStr] = Field(default=None, description="The unique identifier for the insurance")
+    member_id: Optional[StrictStr] = Field(default=None, description="The unique identifier for the member")
+    rx_bin: Optional[StrictStr] = Field(default=None, description="The BIN number for the insurance")
+    rx_pcn: Optional[StrictStr] = Field(default=None, description="The PCN number for the insurance")
+    rx_group: Optional[StrictStr] = Field(default=None, description="The group number for the insurance")
+    __properties: ClassVar[List[str]] = ["uuid", "member_id", "rx_bin", "rx_pcn", "rx_group"]
+
+    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 PatientInsurance 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,
+        )
+        # set to None if rx_pcn (nullable) is None
+        # and model_fields_set contains the field
+        if self.rx_pcn is None and "rx_pcn" in self.model_fields_set:
+            _dict['rx_pcn'] = None
+
+        # set to None if rx_group (nullable) is None
+        # and model_fields_set contains the field
+        if self.rx_group is None and "rx_group" in self.model_fields_set:
+            _dict['rx_group'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatientInsurance from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "uuid": obj.get("uuid"),
+            "member_id": obj.get("member_id"),
+            "rx_bin": obj.get("rx_bin"),
+            "rx_pcn": obj.get("rx_pcn"),
+            "rx_group": obj.get("rx_group")
+        })
+        return _obj
+
+

rxfoundry/clients/swifty_api/models/patient_insurance_data.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    SwiftyRX API
+
+    API for the SwiftyRX Backend 
+
+    The version of the OpenAPI document: 0.1.DEV-0
+    Contact: paul.tindall@rxfoundry.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PatientInsuranceData(BaseModel):
+    """
+    A patient's insurance data.  member_id and rx_bin are combined to form a primary key for the insurance record.
+    """ # noqa: E501
+    object_type: StrictStr = Field(description="The discriminator used to determine the type of the object.  This is required for the discriminator to work correctly.")
+    uuid: Optional[StrictStr] = Field(default=None, description="The insurances' UUID, if known.  If not set, member_id and rx_bin are used to form a primary key for the insurance record.")
+    member_id: StrictStr = Field(description="The insurances' member ID")
+    rx_bin: StrictStr = Field(description="The insurances' RX BIN")
+    rx_pcn: Optional[StrictStr] = Field(default=None, description="The insurances' RX PCN")
+    rx_group: Optional[StrictStr] = Field(default=None, description="The insurances' RX Group Number")
+    __properties: ClassVar[List[str]] = ["object_type", "uuid", "member_id", "rx_bin", "rx_pcn", "rx_group"]
+
+    @field_validator('object_type')
+    def object_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['insurance']):
+            raise ValueError("must be one of enum values ('insurance')")
+        return value
+
+    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 PatientInsuranceData 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 PatientInsuranceData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "uuid": obj.get("uuid"),
+            "member_id": obj.get("member_id"),
+            "rx_bin": obj.get("rx_bin"),
+            "rx_pcn": obj.get("rx_pcn"),
+            "rx_group": obj.get("rx_group")
+        })
+        return _obj
+
+