hubble-sdk-python 0.0.2__py3-none-any.whl

hubble_sdk/_generated/models/consent_source.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..models.consent_source_status import ConsentSourceStatus
+from ..models.consent_source_type import ConsentSourceType
+
+T = TypeVar("T", bound="ConsentSource")
+
+
+@_attrs_define
+class ConsentSource:
+    """
+    Attributes:
+        provider (str): The source as the customer knows it (facility / provider name).
+        type_ (ConsentSourceType): live = an ongoing connection re-readable until its access lapses (EHR, HIE); one_time
+            = a single pull with no ongoing connection (delegated retrieval).
+        status (ConsentSourceStatus): available = records readable now; pending = still being reached out to; failed =
+            retrieval failed.
+    """
+
+    provider: str
+    type_: ConsentSourceType
+    status: ConsentSourceStatus
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider
+
+        type_ = self.type_.value
+
+        status = self.status.value
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "provider": provider,
+                "type": type_,
+                "status": status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        provider = d.pop("provider")
+
+        type_ = ConsentSourceType(d.pop("type"))
+
+        status = ConsentSourceStatus(d.pop("status"))
+
+        consent_source = cls(
+            provider=provider,
+            type_=type_,
+            status=status,
+        )
+
+        return consent_source

hubble_sdk/_generated/models/consent_source_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ConsentSourceStatus(str, Enum):
+    AVAILABLE = "available"
+    FAILED = "failed"
+    PENDING = "pending"
+
+    def __str__(self) -> str:
+        return str(self.value)

hubble_sdk/_generated/models/consent_source_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ConsentSourceType(str, Enum):
+    LIVE = "live"
+    ONE_TIME = "one_time"
+
+    def __str__(self) -> str:
+        return str(self.value)

hubble_sdk/_generated/models/consent_status.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class ConsentStatus(str, Enum):
+    ACTIVE = "active"
+    ERROR = "error"
+    EXPIRED = "expired"
+    PENDING = "pending"
+    REVOKED = "revoked"
+
+    def __str__(self) -> str:
+        return str(self.value)

hubble_sdk/_generated/models/device_authorization_request.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DeviceAuthorizationRequest")
+
+
+@_attrs_define
+class DeviceAuthorizationRequest:
+    """
+    Attributes:
+        patient_ref (str | Unset): Your own reference for the patient, echoed back on the consent.
+        patient_first_name (str | Unset): Patient's legal first name.
+        patient_last_name (str | Unset): Patient's legal last name.
+        patient_birth_date (str | Unset): Patient's date of birth, ISO YYYY-MM-DD.
+        patient_sex (str | Unset): Patient's sex.
+        patient_address_line1 (str | Unset): Patient's street address.
+        patient_city (str | Unset): Patient's city.
+        patient_state (str | Unset): Patient's state or region.
+        patient_postal_code (str | Unset): Patient's postal code.
+        patient_phone (str | Unset): Patient's phone number.
+        patient_email (str | Unset): Patient's email, used as the signer identity.
+        providers (str | Unset): JSON array of provider seeds to prefill the patient's list, each `{ "name", "phone"?
+            }`. Seeded by name (freeform); the patient can add, change, or remove them on the link page.
+    """
+
+    patient_ref: str | Unset = UNSET
+    patient_first_name: str | Unset = UNSET
+    patient_last_name: str | Unset = UNSET
+    patient_birth_date: str | Unset = UNSET
+    patient_sex: str | Unset = UNSET
+    patient_address_line1: str | Unset = UNSET
+    patient_city: str | Unset = UNSET
+    patient_state: str | Unset = UNSET
+    patient_postal_code: str | Unset = UNSET
+    patient_phone: str | Unset = UNSET
+    patient_email: str | Unset = UNSET
+    providers: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        patient_ref = self.patient_ref
+
+        patient_first_name = self.patient_first_name
+
+        patient_last_name = self.patient_last_name
+
+        patient_birth_date = self.patient_birth_date
+
+        patient_sex = self.patient_sex
+
+        patient_address_line1 = self.patient_address_line1
+
+        patient_city = self.patient_city
+
+        patient_state = self.patient_state
+
+        patient_postal_code = self.patient_postal_code
+
+        patient_phone = self.patient_phone
+
+        patient_email = self.patient_email
+
+        providers = self.providers
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({})
+        if patient_ref is not UNSET:
+            field_dict["patient_ref"] = patient_ref
+        if patient_first_name is not UNSET:
+            field_dict["patient_first_name"] = patient_first_name
+        if patient_last_name is not UNSET:
+            field_dict["patient_last_name"] = patient_last_name
+        if patient_birth_date is not UNSET:
+            field_dict["patient_birth_date"] = patient_birth_date
+        if patient_sex is not UNSET:
+            field_dict["patient_sex"] = patient_sex
+        if patient_address_line1 is not UNSET:
+            field_dict["patient_address_line1"] = patient_address_line1
+        if patient_city is not UNSET:
+            field_dict["patient_city"] = patient_city
+        if patient_state is not UNSET:
+            field_dict["patient_state"] = patient_state
+        if patient_postal_code is not UNSET:
+            field_dict["patient_postal_code"] = patient_postal_code
+        if patient_phone is not UNSET:
+            field_dict["patient_phone"] = patient_phone
+        if patient_email is not UNSET:
+            field_dict["patient_email"] = patient_email
+        if providers is not UNSET:
+            field_dict["providers"] = providers
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        patient_ref = d.pop("patient_ref", UNSET)
+
+        patient_first_name = d.pop("patient_first_name", UNSET)
+
+        patient_last_name = d.pop("patient_last_name", UNSET)
+
+        patient_birth_date = d.pop("patient_birth_date", UNSET)
+
+        patient_sex = d.pop("patient_sex", UNSET)
+
+        patient_address_line1 = d.pop("patient_address_line1", UNSET)
+
+        patient_city = d.pop("patient_city", UNSET)
+
+        patient_state = d.pop("patient_state", UNSET)
+
+        patient_postal_code = d.pop("patient_postal_code", UNSET)
+
+        patient_phone = d.pop("patient_phone", UNSET)
+
+        patient_email = d.pop("patient_email", UNSET)
+
+        providers = d.pop("providers", UNSET)
+
+        device_authorization_request = cls(
+            patient_ref=patient_ref,
+            patient_first_name=patient_first_name,
+            patient_last_name=patient_last_name,
+            patient_birth_date=patient_birth_date,
+            patient_sex=patient_sex,
+            patient_address_line1=patient_address_line1,
+            patient_city=patient_city,
+            patient_state=patient_state,
+            patient_postal_code=patient_postal_code,
+            patient_phone=patient_phone,
+            patient_email=patient_email,
+            providers=providers,
+        )
+
+        return device_authorization_request

hubble_sdk/_generated/models/device_authorization_response.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="DeviceAuthorizationResponse")
+
+
+@_attrs_define
+class DeviceAuthorizationResponse:
+    """
+    Attributes:
+        device_code (str): Opaque code your app polls the token endpoint with.
+        user_code (str): Short code shown to the patient (unused in the link flow).
+        verification_uri (str): Base patient link.
+        verification_uri_complete (str): Ready-to-open patient link — send the patient here to authorize.
+        consent_id (str): The consent this authorization will grant.
+        expires_in (int): Seconds until the link and device_code expire.
+        interval (int): Minimum seconds to wait between token-endpoint polls.
+    """
+
+    device_code: str
+    user_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    consent_id: str
+    expires_in: int
+    interval: int
+
+    def to_dict(self) -> dict[str, Any]:
+        device_code = self.device_code
+
+        user_code = self.user_code
+
+        verification_uri = self.verification_uri
+
+        verification_uri_complete = self.verification_uri_complete
+
+        consent_id = self.consent_id
+
+        expires_in = self.expires_in
+
+        interval = self.interval
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "device_code": device_code,
+                "user_code": user_code,
+                "verification_uri": verification_uri,
+                "verification_uri_complete": verification_uri_complete,
+                "consent_id": consent_id,
+                "expires_in": expires_in,
+                "interval": interval,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        device_code = d.pop("device_code")
+
+        user_code = d.pop("user_code")
+
+        verification_uri = d.pop("verification_uri")
+
+        verification_uri_complete = d.pop("verification_uri_complete")
+
+        consent_id = d.pop("consent_id")
+
+        expires_in = d.pop("expires_in")
+
+        interval = d.pop("interval")
+
+        device_authorization_response = cls(
+            device_code=device_code,
+            user_code=user_code,
+            verification_uri=verification_uri,
+            verification_uri_complete=verification_uri_complete,
+            consent_id=consent_id,
+            expires_in=expires_in,
+            interval=interval,
+        )
+
+        return device_authorization_response

hubble_sdk/_generated/models/fhir_resource.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="FhirResource")
+
+
+@_attrs_define
+class FhirResource:
+    """An arbitrary FHIR R4 resource. Has a `resourceType`; otherwise open.
+
+    Attributes:
+        resource_type (str):
+    """
+
+    resource_type: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        resource_type = self.resource_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "resourceType": resource_type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        resource_type = d.pop("resourceType")
+
+        fhir_resource = cls(
+            resource_type=resource_type,
+        )
+
+        fhir_resource.additional_properties = d
+        return fhir_resource
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hubble_sdk/_generated/models/o_auth_error.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..models.o_auth_error_error import OAuthErrorError
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OAuthError")
+
+
+@_attrs_define
+class OAuthError:
+    """
+    Attributes:
+        error (OAuthErrorError):
+        error_description (str | Unset):
+    """
+
+    error: OAuthErrorError
+    error_description: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error.value
+
+        error_description = self.error_description
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+        if error_description is not UNSET:
+            field_dict["error_description"] = error_description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        error = OAuthErrorError(d.pop("error"))
+
+        error_description = d.pop("error_description", UNSET)
+
+        o_auth_error = cls(
+            error=error,
+            error_description=error_description,
+        )
+
+        return o_auth_error

hubble_sdk/_generated/models/o_auth_error_error.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class OAuthErrorError(str, Enum):
+    ACCESS_DENIED = "access_denied"
+    AUTHORIZATION_PENDING = "authorization_pending"
+    EXPIRED_TOKEN = "expired_token"
+    INVALID_CLIENT = "invalid_client"
+    INVALID_GRANT = "invalid_grant"
+    INVALID_REQUEST = "invalid_request"
+    SERVER_ERROR = "server_error"
+    SLOW_DOWN = "slow_down"
+    UNSUPPORTED_GRANT_TYPE = "unsupported_grant_type"
+
+    def __str__(self) -> str:
+        return str(self.value)

hubble_sdk/_generated/models/operation_outcome.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    Self,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+
+if TYPE_CHECKING:
+    from ..models.operation_outcome_issue_item import OperationOutcomeIssueItem
+
+
+T = TypeVar("T", bound="OperationOutcome")
+
+
+@_attrs_define
+class OperationOutcome:
+    """
+    Attributes:
+        resource_type (Literal['OperationOutcome']):
+        issue (list[OperationOutcomeIssueItem]):
+    """
+
+    resource_type: Literal["OperationOutcome"]
+    issue: list[OperationOutcomeIssueItem]
+
+    def to_dict(self) -> dict[str, Any]:
+        resource_type = self.resource_type
+
+        issue = []
+        for issue_item_data in self.issue:
+            issue_item = issue_item_data.to_dict()
+            issue.append(issue_item)
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "resourceType": resource_type,
+                "issue": issue,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.operation_outcome_issue_item import OperationOutcomeIssueItem
+
+        d = dict(src_dict)
+        resource_type = cast(Literal["OperationOutcome"], d.pop("resourceType"))
+        if resource_type != "OperationOutcome":
+            raise ValueError(
+                f"resourceType must match const 'OperationOutcome', got '{resource_type}'"
+            )
+
+        issue = []
+        _issue = d.pop("issue")
+        for issue_item_data in _issue:
+            issue_item = OperationOutcomeIssueItem.from_dict(issue_item_data)
+
+            issue.append(issue_item)
+
+        operation_outcome = cls(
+            resource_type=resource_type,
+            issue=issue,
+        )
+
+        return operation_outcome

hubble_sdk/_generated/models/operation_outcome_issue_item.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OperationOutcomeIssueItem")
+
+
+@_attrs_define
+class OperationOutcomeIssueItem:
+    """
+    Attributes:
+        severity (str):
+        code (str):
+        diagnostics (str | Unset):
+    """
+
+    severity: str
+    code: str
+    diagnostics: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        severity = self.severity
+
+        code = self.code
+
+        diagnostics = self.diagnostics
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "severity": severity,
+                "code": code,
+            }
+        )
+        if diagnostics is not UNSET:
+            field_dict["diagnostics"] = diagnostics
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        severity = d.pop("severity")
+
+        code = d.pop("code")
+
+        diagnostics = d.pop("diagnostics", UNSET)
+
+        operation_outcome_issue_item = cls(
+            severity=severity,
+            code=code,
+            diagnostics=diagnostics,
+        )
+
+        return operation_outcome_issue_item

hubble_sdk/_generated/models/patient_address.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatientAddress")
+
+
+@_attrs_define
+class PatientAddress:
+    """
+    Attributes:
+        line1 (str | Unset): Street address.
+        city (str | Unset): City.
+        state (str | Unset): State or region.
+        postal_code (str | Unset): Postal code.
+    """
+
+    line1: str | Unset = UNSET
+    city: str | Unset = UNSET
+    state: str | Unset = UNSET
+    postal_code: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        line1 = self.line1
+
+        city = self.city
+
+        state = self.state
+
+        postal_code = self.postal_code
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({})
+        if line1 is not UNSET:
+            field_dict["line1"] = line1
+        if city is not UNSET:
+            field_dict["city"] = city
+        if state is not UNSET:
+            field_dict["state"] = state
+        if postal_code is not UNSET:
+            field_dict["postal_code"] = postal_code
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        line1 = d.pop("line1", UNSET)
+
+        city = d.pop("city", UNSET)
+
+        state = d.pop("state", UNSET)
+
+        postal_code = d.pop("postal_code", UNSET)
+
+        patient_address = cls(
+            line1=line1,
+            city=city,
+            state=state,
+            postal_code=postal_code,
+        )
+
+        return patient_address