bluehive 0.1.0a20__py3-none-any.whl → 0.1.0a22__py3-none-any.whl

bluehive/_base_client.py

@@ -9,6 +9,7 @@ import asyncio
 import inspect
 import logging
 import platform
+import warnings
 import email.utils
 from types import TracebackType
 from random import random
@@ -51,9 +52,11 @@ from ._types import (
     ResponseT,
     AnyMapping,
     PostParser,
+    BinaryTypes,
     RequestFiles,
     HttpxSendArgs,
     RequestOptions,
+    AsyncBinaryTypes,
     HttpxRequestFiles,
     ModelBuilderProtocol,
     not_given,
@@ -477,8 +480,19 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         retries_taken: int = 0,
     ) -> httpx.Request:
         if log.isEnabledFor(logging.DEBUG):
-            log.debug("Request options: %s", model_dump(options, exclude_unset=True))
-
+            log.debug(
+                "Request options: %s",
+                model_dump(
+                    options,
+                    exclude_unset=True,
+                    # Pydantic v1 can't dump every type we support in content, so we exclude it for now.
+                    exclude={
+                        "content",
+                    }
+                    if PYDANTIC_V1
+                    else {},
+                ),
+            )
         kwargs: dict[str, Any] = {}
 
         json_data = options.json_data
@@ -532,7 +546,13 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         is_body_allowed = options.method.lower() != "get"
 
         if is_body_allowed:
-            if isinstance(json_data, bytes):
+            if options.content is not None and json_data is not None:
+                raise TypeError("Passing both `content` and `json_data` is not supported")
+            if options.content is not None and files is not None:
+                raise TypeError("Passing both `content` and `files` is not supported")
+            if options.content is not None:
+                kwargs["content"] = options.content
+            elif isinstance(json_data, bytes):
                 kwargs["content"] = json_data
             else:
                 kwargs["json"] = json_data if is_given(json_data) else None
@@ -1194,6 +1214,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: Literal[False] = False,
@@ -1206,6 +1227,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: Literal[True],
@@ -1219,6 +1241,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: bool,
@@ -1231,13 +1254,25 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: bool = False,
         stream_cls: type[_StreamT] | None = None,
     ) -> ResponseT | _StreamT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="post", url=path, json_data=body, files=to_httpx_files(files), **options
+            method="post", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
         )
         return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))
 
@@ -1247,9 +1282,24 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
+        files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(
+            method="patch", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
+        )
         return self.request(cast_to, opts)
 
     def put(
@@ -1258,11 +1308,23 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="put", url=path, json_data=body, files=to_httpx_files(files), **options
+            method="put", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
         )
         return self.request(cast_to, opts)
 
@@ -1272,9 +1334,19 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, content=content, **options)
         return self.request(cast_to, opts)
 
     def get_api_list(
@@ -1714,6 +1786,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: Literal[False] = False,
@@ -1726,6 +1799,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: Literal[True],
@@ -1739,6 +1813,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: bool,
@@ -1751,13 +1826,25 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: bool = False,
         stream_cls: type[_AsyncStreamT] | None = None,
     ) -> ResponseT | _AsyncStreamT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="post", url=path, json_data=body, files=await async_to_httpx_files(files), **options
+            method="post", url=path, json_data=body, content=content, files=await async_to_httpx_files(files), **options
         )
         return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)
 
@@ -1767,9 +1854,29 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
+        files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(
+            method="patch",
+            url=path,
+            json_data=body,
+            content=content,
+            files=await async_to_httpx_files(files),
+            **options,
+        )
         return await self.request(cast_to, opts)
 
     async def put(
@@ -1778,11 +1885,23 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="put", url=path, json_data=body, files=await async_to_httpx_files(files), **options
+            method="put", url=path, json_data=body, content=content, files=await async_to_httpx_files(files), **options
         )
         return await self.request(cast_to, opts)
 
@@ -1792,9 +1911,19 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, content=content, **options)
         return await self.request(cast_to, opts)
 
     def get_api_list(

bluehive/_client.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Mapping
+from typing import TYPE_CHECKING, Any, Mapping
 from typing_extensions import Self, override
 
 import httpx
@@ -20,8 +20,8 @@ from ._types import (
     not_given,
 )
 from ._utils import is_given, get_async_library
+from ._compat import cached_property
 from ._version import __version__
-from .resources import fax, hl7, health, orders, version, database, employees, providers, integrations
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import BlueHiveError, APIStatusError
 from ._base_client import (
@@ -29,7 +29,19 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.employers import employers
+
+if TYPE_CHECKING:
+    from .resources import fax, hl7, health, orders, version, database, employees, employers, providers, integrations
+    from .resources.fax import FaxResource, AsyncFaxResource
+    from .resources.hl7 import Hl7Resource, AsyncHl7Resource
+    from .resources.health import HealthResource, AsyncHealthResource
+    from .resources.orders import OrdersResource, AsyncOrdersResource
+    from .resources.version import VersionResource, AsyncVersionResource
+    from .resources.database import DatabaseResource, AsyncDatabaseResource
+    from .resources.employees import EmployeesResource, AsyncEmployeesResource
+    from .resources.providers import ProvidersResource, AsyncProvidersResource
+    from .resources.integrations import IntegrationsResource, AsyncIntegrationsResource
+    from .resources.employers.employers import EmployersResource, AsyncEmployersResource
 
 __all__ = [
     "Timeout",
@@ -44,19 +56,6 @@ __all__ = [
 
 
 class BlueHive(SyncAPIClient):
-    health: health.HealthResource
-    version: version.VersionResource
-    providers: providers.ProvidersResource
-    database: database.DatabaseResource
-    fax: fax.FaxResource
-    employers: employers.EmployersResource
-    hl7: hl7.Hl7Resource
-    orders: orders.OrdersResource
-    employees: employees.EmployeesResource
-    integrations: integrations.IntegrationsResource
-    with_raw_response: BlueHiveWithRawResponse
-    with_streaming_response: BlueHiveWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -111,18 +110,73 @@ class BlueHive(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.health = health.HealthResource(self)
-        self.version = version.VersionResource(self)
-        self.providers = providers.ProvidersResource(self)
-        self.database = database.DatabaseResource(self)
-        self.fax = fax.FaxResource(self)
-        self.employers = employers.EmployersResource(self)
-        self.hl7 = hl7.Hl7Resource(self)
-        self.orders = orders.OrdersResource(self)
-        self.employees = employees.EmployeesResource(self)
-        self.integrations = integrations.IntegrationsResource(self)
-        self.with_raw_response = BlueHiveWithRawResponse(self)
-        self.with_streaming_response = BlueHiveWithStreamedResponse(self)
+    @cached_property
+    def health(self) -> HealthResource:
+        from .resources.health import HealthResource
+
+        return HealthResource(self)
+
+    @cached_property
+    def version(self) -> VersionResource:
+        from .resources.version import VersionResource
+
+        return VersionResource(self)
+
+    @cached_property
+    def providers(self) -> ProvidersResource:
+        from .resources.providers import ProvidersResource
+
+        return ProvidersResource(self)
+
+    @cached_property
+    def database(self) -> DatabaseResource:
+        from .resources.database import DatabaseResource
+
+        return DatabaseResource(self)
+
+    @cached_property
+    def fax(self) -> FaxResource:
+        from .resources.fax import FaxResource
+
+        return FaxResource(self)
+
+    @cached_property
+    def employers(self) -> EmployersResource:
+        from .resources.employers import EmployersResource
+
+        return EmployersResource(self)
+
+    @cached_property
+    def hl7(self) -> Hl7Resource:
+        from .resources.hl7 import Hl7Resource
+
+        return Hl7Resource(self)
+
+    @cached_property
+    def orders(self) -> OrdersResource:
+        from .resources.orders import OrdersResource
+
+        return OrdersResource(self)
+
+    @cached_property
+    def employees(self) -> EmployeesResource:
+        from .resources.employees import EmployeesResource
+
+        return EmployeesResource(self)
+
+    @cached_property
+    def integrations(self) -> IntegrationsResource:
+        from .resources.integrations import IntegrationsResource
+
+        return IntegrationsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> BlueHiveWithRawResponse:
+        return BlueHiveWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BlueHiveWithStreamedResponse:
+        return BlueHiveWithStreamedResponse(self)
 
     @property
     @override
@@ -230,19 +284,6 @@ class BlueHive(SyncAPIClient):
 
 
 class AsyncBlueHive(AsyncAPIClient):
-    health: health.AsyncHealthResource
-    version: version.AsyncVersionResource
-    providers: providers.AsyncProvidersResource
-    database: database.AsyncDatabaseResource
-    fax: fax.AsyncFaxResource
-    employers: employers.AsyncEmployersResource
-    hl7: hl7.AsyncHl7Resource
-    orders: orders.AsyncOrdersResource
-    employees: employees.AsyncEmployeesResource
-    integrations: integrations.AsyncIntegrationsResource
-    with_raw_response: AsyncBlueHiveWithRawResponse
-    with_streaming_response: AsyncBlueHiveWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -297,18 +338,73 @@ class AsyncBlueHive(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.health = health.AsyncHealthResource(self)
-        self.version = version.AsyncVersionResource(self)
-        self.providers = providers.AsyncProvidersResource(self)
-        self.database = database.AsyncDatabaseResource(self)
-        self.fax = fax.AsyncFaxResource(self)
-        self.employers = employers.AsyncEmployersResource(self)
-        self.hl7 = hl7.AsyncHl7Resource(self)
-        self.orders = orders.AsyncOrdersResource(self)
-        self.employees = employees.AsyncEmployeesResource(self)
-        self.integrations = integrations.AsyncIntegrationsResource(self)
-        self.with_raw_response = AsyncBlueHiveWithRawResponse(self)
-        self.with_streaming_response = AsyncBlueHiveWithStreamedResponse(self)
+    @cached_property
+    def health(self) -> AsyncHealthResource:
+        from .resources.health import AsyncHealthResource
+
+        return AsyncHealthResource(self)
+
+    @cached_property
+    def version(self) -> AsyncVersionResource:
+        from .resources.version import AsyncVersionResource
+
+        return AsyncVersionResource(self)
+
+    @cached_property
+    def providers(self) -> AsyncProvidersResource:
+        from .resources.providers import AsyncProvidersResource
+
+        return AsyncProvidersResource(self)
+
+    @cached_property
+    def database(self) -> AsyncDatabaseResource:
+        from .resources.database import AsyncDatabaseResource
+
+        return AsyncDatabaseResource(self)
+
+    @cached_property
+    def fax(self) -> AsyncFaxResource:
+        from .resources.fax import AsyncFaxResource
+
+        return AsyncFaxResource(self)
+
+    @cached_property
+    def employers(self) -> AsyncEmployersResource:
+        from .resources.employers import AsyncEmployersResource
+
+        return AsyncEmployersResource(self)
+
+    @cached_property
+    def hl7(self) -> AsyncHl7Resource:
+        from .resources.hl7 import AsyncHl7Resource
+
+        return AsyncHl7Resource(self)
+
+    @cached_property
+    def orders(self) -> AsyncOrdersResource:
+        from .resources.orders import AsyncOrdersResource
+
+        return AsyncOrdersResource(self)
+
+    @cached_property
+    def employees(self) -> AsyncEmployeesResource:
+        from .resources.employees import AsyncEmployeesResource
+
+        return AsyncEmployeesResource(self)
+
+    @cached_property
+    def integrations(self) -> AsyncIntegrationsResource:
+        from .resources.integrations import AsyncIntegrationsResource
+
+        return AsyncIntegrationsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBlueHiveWithRawResponse:
+        return AsyncBlueHiveWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBlueHiveWithStreamedResponse:
+        return AsyncBlueHiveWithStreamedResponse(self)
 
     @property
     @override
@@ -416,59 +512,271 @@ class AsyncBlueHive(AsyncAPIClient):
 
 
 class BlueHiveWithRawResponse:
+    _client: BlueHive
+
     def __init__(self, client: BlueHive) -> None:
-        self.health = health.HealthResourceWithRawResponse(client.health)
-        self.version = version.VersionResourceWithRawResponse(client.version)
-        self.providers = providers.ProvidersResourceWithRawResponse(client.providers)
-        self.database = database.DatabaseResourceWithRawResponse(client.database)
-        self.fax = fax.FaxResourceWithRawResponse(client.fax)
-        self.employers = employers.EmployersResourceWithRawResponse(client.employers)
-        self.hl7 = hl7.Hl7ResourceWithRawResponse(client.hl7)
-        self.orders = orders.OrdersResourceWithRawResponse(client.orders)
-        self.employees = employees.EmployeesResourceWithRawResponse(client.employees)
-        self.integrations = integrations.IntegrationsResourceWithRawResponse(client.integrations)
+        self._client = client
+
+    @cached_property
+    def health(self) -> health.HealthResourceWithRawResponse:
+        from .resources.health import HealthResourceWithRawResponse
+
+        return HealthResourceWithRawResponse(self._client.health)
+
+    @cached_property
+    def version(self) -> version.VersionResourceWithRawResponse:
+        from .resources.version import VersionResourceWithRawResponse
+
+        return VersionResourceWithRawResponse(self._client.version)
+
+    @cached_property
+    def providers(self) -> providers.ProvidersResourceWithRawResponse:
+        from .resources.providers import ProvidersResourceWithRawResponse
+
+        return ProvidersResourceWithRawResponse(self._client.providers)
+
+    @cached_property
+    def database(self) -> database.DatabaseResourceWithRawResponse:
+        from .resources.database import DatabaseResourceWithRawResponse
+
+        return DatabaseResourceWithRawResponse(self._client.database)
+
+    @cached_property
+    def fax(self) -> fax.FaxResourceWithRawResponse:
+        from .resources.fax import FaxResourceWithRawResponse
+
+        return FaxResourceWithRawResponse(self._client.fax)
+
+    @cached_property
+    def employers(self) -> employers.EmployersResourceWithRawResponse:
+        from .resources.employers import EmployersResourceWithRawResponse
+
+        return EmployersResourceWithRawResponse(self._client.employers)
+
+    @cached_property
+    def hl7(self) -> hl7.Hl7ResourceWithRawResponse:
+        from .resources.hl7 import Hl7ResourceWithRawResponse
+
+        return Hl7ResourceWithRawResponse(self._client.hl7)
+
+    @cached_property
+    def orders(self) -> orders.OrdersResourceWithRawResponse:
+        from .resources.orders import OrdersResourceWithRawResponse
+
+        return OrdersResourceWithRawResponse(self._client.orders)
+
+    @cached_property
+    def employees(self) -> employees.EmployeesResourceWithRawResponse:
+        from .resources.employees import EmployeesResourceWithRawResponse
+
+        return EmployeesResourceWithRawResponse(self._client.employees)
+
+    @cached_property
+    def integrations(self) -> integrations.IntegrationsResourceWithRawResponse:
+        from .resources.integrations import IntegrationsResourceWithRawResponse
+
+        return IntegrationsResourceWithRawResponse(self._client.integrations)
 
 
 class AsyncBlueHiveWithRawResponse:
+    _client: AsyncBlueHive
+
     def __init__(self, client: AsyncBlueHive) -> None:
-        self.health = health.AsyncHealthResourceWithRawResponse(client.health)
-        self.version = version.AsyncVersionResourceWithRawResponse(client.version)
-        self.providers = providers.AsyncProvidersResourceWithRawResponse(client.providers)
-        self.database = database.AsyncDatabaseResourceWithRawResponse(client.database)
-        self.fax = fax.AsyncFaxResourceWithRawResponse(client.fax)
-        self.employers = employers.AsyncEmployersResourceWithRawResponse(client.employers)
-        self.hl7 = hl7.AsyncHl7ResourceWithRawResponse(client.hl7)
-        self.orders = orders.AsyncOrdersResourceWithRawResponse(client.orders)
-        self.employees = employees.AsyncEmployeesResourceWithRawResponse(client.employees)
-        self.integrations = integrations.AsyncIntegrationsResourceWithRawResponse(client.integrations)
+        self._client = client
+
+    @cached_property
+    def health(self) -> health.AsyncHealthResourceWithRawResponse:
+        from .resources.health import AsyncHealthResourceWithRawResponse
+
+        return AsyncHealthResourceWithRawResponse(self._client.health)
+
+    @cached_property
+    def version(self) -> version.AsyncVersionResourceWithRawResponse:
+        from .resources.version import AsyncVersionResourceWithRawResponse
+
+        return AsyncVersionResourceWithRawResponse(self._client.version)
+
+    @cached_property
+    def providers(self) -> providers.AsyncProvidersResourceWithRawResponse:
+        from .resources.providers import AsyncProvidersResourceWithRawResponse
+
+        return AsyncProvidersResourceWithRawResponse(self._client.providers)
+
+    @cached_property
+    def database(self) -> database.AsyncDatabaseResourceWithRawResponse:
+        from .resources.database import AsyncDatabaseResourceWithRawResponse
+
+        return AsyncDatabaseResourceWithRawResponse(self._client.database)
+
+    @cached_property
+    def fax(self) -> fax.AsyncFaxResourceWithRawResponse:
+        from .resources.fax import AsyncFaxResourceWithRawResponse
+
+        return AsyncFaxResourceWithRawResponse(self._client.fax)
+
+    @cached_property
+    def employers(self) -> employers.AsyncEmployersResourceWithRawResponse:
+        from .resources.employers import AsyncEmployersResourceWithRawResponse
+
+        return AsyncEmployersResourceWithRawResponse(self._client.employers)
+
+    @cached_property
+    def hl7(self) -> hl7.AsyncHl7ResourceWithRawResponse:
+        from .resources.hl7 import AsyncHl7ResourceWithRawResponse
+
+        return AsyncHl7ResourceWithRawResponse(self._client.hl7)
+
+    @cached_property
+    def orders(self) -> orders.AsyncOrdersResourceWithRawResponse:
+        from .resources.orders import AsyncOrdersResourceWithRawResponse
+
+        return AsyncOrdersResourceWithRawResponse(self._client.orders)
+
+    @cached_property
+    def employees(self) -> employees.AsyncEmployeesResourceWithRawResponse:
+        from .resources.employees import AsyncEmployeesResourceWithRawResponse
+
+        return AsyncEmployeesResourceWithRawResponse(self._client.employees)
+
+    @cached_property
+    def integrations(self) -> integrations.AsyncIntegrationsResourceWithRawResponse:
+        from .resources.integrations import AsyncIntegrationsResourceWithRawResponse
+
+        return AsyncIntegrationsResourceWithRawResponse(self._client.integrations)
 
 
 class BlueHiveWithStreamedResponse:
+    _client: BlueHive
+
     def __init__(self, client: BlueHive) -> None:
-        self.health = health.HealthResourceWithStreamingResponse(client.health)
-        self.version = version.VersionResourceWithStreamingResponse(client.version)
-        self.providers = providers.ProvidersResourceWithStreamingResponse(client.providers)
-        self.database = database.DatabaseResourceWithStreamingResponse(client.database)
-        self.fax = fax.FaxResourceWithStreamingResponse(client.fax)
-        self.employers = employers.EmployersResourceWithStreamingResponse(client.employers)
-        self.hl7 = hl7.Hl7ResourceWithStreamingResponse(client.hl7)
-        self.orders = orders.OrdersResourceWithStreamingResponse(client.orders)
-        self.employees = employees.EmployeesResourceWithStreamingResponse(client.employees)
-        self.integrations = integrations.IntegrationsResourceWithStreamingResponse(client.integrations)
+        self._client = client
+
+    @cached_property
+    def health(self) -> health.HealthResourceWithStreamingResponse:
+        from .resources.health import HealthResourceWithStreamingResponse
+
+        return HealthResourceWithStreamingResponse(self._client.health)
+
+    @cached_property
+    def version(self) -> version.VersionResourceWithStreamingResponse:
+        from .resources.version import VersionResourceWithStreamingResponse
+
+        return VersionResourceWithStreamingResponse(self._client.version)
+
+    @cached_property
+    def providers(self) -> providers.ProvidersResourceWithStreamingResponse:
+        from .resources.providers import ProvidersResourceWithStreamingResponse
+
+        return ProvidersResourceWithStreamingResponse(self._client.providers)
+
+    @cached_property
+    def database(self) -> database.DatabaseResourceWithStreamingResponse:
+        from .resources.database import DatabaseResourceWithStreamingResponse
+
+        return DatabaseResourceWithStreamingResponse(self._client.database)
+
+    @cached_property
+    def fax(self) -> fax.FaxResourceWithStreamingResponse:
+        from .resources.fax import FaxResourceWithStreamingResponse
+
+        return FaxResourceWithStreamingResponse(self._client.fax)
+
+    @cached_property
+    def employers(self) -> employers.EmployersResourceWithStreamingResponse:
+        from .resources.employers import EmployersResourceWithStreamingResponse
+
+        return EmployersResourceWithStreamingResponse(self._client.employers)
+
+    @cached_property
+    def hl7(self) -> hl7.Hl7ResourceWithStreamingResponse:
+        from .resources.hl7 import Hl7ResourceWithStreamingResponse
+
+        return Hl7ResourceWithStreamingResponse(self._client.hl7)
+
+    @cached_property
+    def orders(self) -> orders.OrdersResourceWithStreamingResponse:
+        from .resources.orders import OrdersResourceWithStreamingResponse
+
+        return OrdersResourceWithStreamingResponse(self._client.orders)
+
+    @cached_property
+    def employees(self) -> employees.EmployeesResourceWithStreamingResponse:
+        from .resources.employees import EmployeesResourceWithStreamingResponse
+
+        return EmployeesResourceWithStreamingResponse(self._client.employees)
+
+    @cached_property
+    def integrations(self) -> integrations.IntegrationsResourceWithStreamingResponse:
+        from .resources.integrations import IntegrationsResourceWithStreamingResponse
+
+        return IntegrationsResourceWithStreamingResponse(self._client.integrations)
 
 
 class AsyncBlueHiveWithStreamedResponse:
+    _client: AsyncBlueHive
+
     def __init__(self, client: AsyncBlueHive) -> None:
-        self.health = health.AsyncHealthResourceWithStreamingResponse(client.health)
-        self.version = version.AsyncVersionResourceWithStreamingResponse(client.version)
-        self.providers = providers.AsyncProvidersResourceWithStreamingResponse(client.providers)
-        self.database = database.AsyncDatabaseResourceWithStreamingResponse(client.database)
-        self.fax = fax.AsyncFaxResourceWithStreamingResponse(client.fax)
-        self.employers = employers.AsyncEmployersResourceWithStreamingResponse(client.employers)
-        self.hl7 = hl7.AsyncHl7ResourceWithStreamingResponse(client.hl7)
-        self.orders = orders.AsyncOrdersResourceWithStreamingResponse(client.orders)
-        self.employees = employees.AsyncEmployeesResourceWithStreamingResponse(client.employees)
-        self.integrations = integrations.AsyncIntegrationsResourceWithStreamingResponse(client.integrations)
+        self._client = client
+
+    @cached_property
+    def health(self) -> health.AsyncHealthResourceWithStreamingResponse:
+        from .resources.health import AsyncHealthResourceWithStreamingResponse
+
+        return AsyncHealthResourceWithStreamingResponse(self._client.health)
+
+    @cached_property
+    def version(self) -> version.AsyncVersionResourceWithStreamingResponse:
+        from .resources.version import AsyncVersionResourceWithStreamingResponse
+
+        return AsyncVersionResourceWithStreamingResponse(self._client.version)
+
+    @cached_property
+    def providers(self) -> providers.AsyncProvidersResourceWithStreamingResponse:
+        from .resources.providers import AsyncProvidersResourceWithStreamingResponse
+
+        return AsyncProvidersResourceWithStreamingResponse(self._client.providers)
+
+    @cached_property
+    def database(self) -> database.AsyncDatabaseResourceWithStreamingResponse:
+        from .resources.database import AsyncDatabaseResourceWithStreamingResponse
+
+        return AsyncDatabaseResourceWithStreamingResponse(self._client.database)
+
+    @cached_property
+    def fax(self) -> fax.AsyncFaxResourceWithStreamingResponse:
+        from .resources.fax import AsyncFaxResourceWithStreamingResponse
+
+        return AsyncFaxResourceWithStreamingResponse(self._client.fax)
+
+    @cached_property
+    def employers(self) -> employers.AsyncEmployersResourceWithStreamingResponse:
+        from .resources.employers import AsyncEmployersResourceWithStreamingResponse
+
+        return AsyncEmployersResourceWithStreamingResponse(self._client.employers)
+
+    @cached_property
+    def hl7(self) -> hl7.AsyncHl7ResourceWithStreamingResponse:
+        from .resources.hl7 import AsyncHl7ResourceWithStreamingResponse
+
+        return AsyncHl7ResourceWithStreamingResponse(self._client.hl7)
+
+    @cached_property
+    def orders(self) -> orders.AsyncOrdersResourceWithStreamingResponse:
+        from .resources.orders import AsyncOrdersResourceWithStreamingResponse
+
+        return AsyncOrdersResourceWithStreamingResponse(self._client.orders)
+
+    @cached_property
+    def employees(self) -> employees.AsyncEmployeesResourceWithStreamingResponse:
+        from .resources.employees import AsyncEmployeesResourceWithStreamingResponse
+
+        return AsyncEmployeesResourceWithStreamingResponse(self._client.employees)
+
+    @cached_property
+    def integrations(self) -> integrations.AsyncIntegrationsResourceWithStreamingResponse:
+        from .resources.integrations import AsyncIntegrationsResourceWithStreamingResponse
+
+        return AsyncIntegrationsResourceWithStreamingResponse(self._client.integrations)
 
 
 Client = BlueHive

bluehive/_models.py

@@ -3,7 +3,20 @@ from __future__ import annotations
 import os
 import inspect
 import weakref
-from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Type,
+    Union,
+    Generic,
+    TypeVar,
+    Callable,
+    Iterable,
+    Optional,
+    AsyncIterable,
+    cast,
+)
 from datetime import date, datetime
 from typing_extensions import (
     List,
@@ -787,6 +800,7 @@ class FinalRequestOptionsInput(TypedDict, total=False):
     timeout: float | Timeout | None
     files: HttpxRequestFiles | None
     idempotency_key: str
+    content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None]
     json_data: Body
     extra_json: AnyMapping
     follow_redirects: bool
@@ -805,6 +819,7 @@ class FinalRequestOptions(pydantic.BaseModel):
     post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven()
     follow_redirects: Union[bool, None] = None
 
+    content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None] = None
     # It should be noted that we cannot use `json` here as that would override
     # a BaseModel method in an incompatible fashion.
     json_data: Union[Body, None] = None

bluehive/_types.py

@@ -13,9 +13,11 @@ from typing import (
     Mapping,
     TypeVar,
     Callable,
+    Iterable,
     Iterator,
     Optional,
     Sequence,
+    AsyncIterable,
 )
 from typing_extensions import (
     Set,
@@ -56,6 +58,13 @@ if TYPE_CHECKING:
 else:
     Base64FileInput = Union[IO[bytes], PathLike]
     FileContent = Union[IO[bytes], bytes, PathLike]  # PathLike is not subscriptable in Python 3.8.
+
+
+# Used for sending raw binary data / streaming data in request bodies
+# e.g. for file uploads without multipart encoding
+BinaryTypes = Union[bytes, bytearray, IO[bytes], Iterable[bytes]]
+AsyncBinaryTypes = Union[bytes, bytearray, IO[bytes], AsyncIterable[bytes]]
+
 FileTypes = Union[
     # file (or bytes)
     FileContent,

bluehive/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "bluehive"
-__version__ = "0.1.0-alpha.20"  # x-release-please-version
+__version__ = "0.1.0-alpha.22"  # x-release-please-version

bluehive/types/database_check_health_response.py

@@ -11,6 +11,8 @@ __all__ = ["DatabaseCheckHealthResponse", "Stats"]
 
 
 class Stats(BaseModel):
+    """Database statistics (not available in production)"""
+
     collections: Optional[float] = None
     """Number of collections"""
 

bluehive/types/employee_create_response.py

@@ -8,6 +8,8 @@ __all__ = ["EmployeeCreateResponse"]
 
 
 class EmployeeCreateResponse(BaseModel):
+    """Employee created successfully"""
+
     employee_id: str = FieldInfo(alias="employeeId")
     """ID of the created employee"""
 

bluehive/types/employee_delete_response.py

@@ -6,6 +6,8 @@ __all__ = ["EmployeeDeleteResponse"]
 
 
 class EmployeeDeleteResponse(BaseModel):
+    """Employee deleted successfully"""
+
     message: str
 
     success: bool

bluehive/types/employee_link_user_response.py

@@ -8,6 +8,8 @@ __all__ = ["EmployeeLinkUserResponse"]
 
 
 class EmployeeLinkUserResponse(BaseModel):
+    """Employee linked successfully"""
+
     link_id: str = FieldInfo(alias="linkId")
     """ID of the created link"""
 

bluehive/types/employee_list_response.py

@@ -12,6 +12,8 @@ __all__ = ["EmployeeListResponse", "Employee", "EmployeeAddress", "EmployeeExten
 
 
 class EmployeeAddress(BaseModel):
+    """Employee address"""
+
     city: str
     """City"""
 
@@ -51,6 +53,8 @@ class EmployeePhone(BaseModel):
 
 
 class Employee(BaseModel):
+    """Employee details"""
+
     api_id: str = FieldInfo(alias="_id")
     """Unique identifier"""
 
@@ -104,6 +108,8 @@ class Employee(BaseModel):
 
 
 class EmployeeListResponse(BaseModel):
+    """Employees retrieved successfully"""
+
     employees: List[Employee]
     """List of employees"""
 

bluehive/types/employee_retrieve_response.py

@@ -12,6 +12,8 @@ __all__ = ["EmployeeRetrieveResponse", "Employee", "EmployeeAddress", "EmployeeE
 
 
 class EmployeeAddress(BaseModel):
+    """Employee address"""
+
     city: str
     """City"""
 
@@ -51,6 +53,8 @@ class EmployeePhone(BaseModel):
 
 
 class Employee(BaseModel):
+    """Employee details"""
+
     api_id: str = FieldInfo(alias="_id")
     """Unique identifier"""
 
@@ -104,6 +108,8 @@ class Employee(BaseModel):
 
 
 class EmployeeRetrieveResponse(BaseModel):
+    """Employee found successfully"""
+
     employee: Employee
     """Employee details"""
 

bluehive/types/employee_unlink_user_response.py

@@ -6,6 +6,8 @@ __all__ = ["EmployeeUnlinkUserResponse"]
 
 
 class EmployeeUnlinkUserResponse(BaseModel):
+    """Employee unlinked successfully"""
+
     message: str
 
     success: bool

bluehive/types/employee_update_response.py

@@ -6,6 +6,8 @@ __all__ = ["EmployeeUpdateResponse"]
 
 
 class EmployeeUpdateResponse(BaseModel):
+    """Employee updated successfully"""
+
     message: str
 
     success: bool

bluehive/types/hl7_send_results_params.py

@@ -18,6 +18,8 @@ class Hl7SendResultsParams(TypedDict, total=False):
 
 
 class File(TypedDict, total=False):
+    """File containing the results"""
+
     base64: Required[str]
     """Base64 encoded file content"""
 

{bluehive-0.1.0a20.dist-info → bluehive-0.1.0a22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bluehive
-Version: 0.1.0a20
+Version: 0.1.0a22
 Summary: The official Python library for the bluehive API
 Project-URL: Homepage, https://github.com/bluehive-health/bluehive-sdk-python
 Project-URL: Repository, https://github.com/bluehive-health/bluehive-sdk-python
@@ -44,6 +44,15 @@ and offers both synchronous and asynchronous clients powered by [httpx](https://
 
 It is generated with [Stainless](https://www.stainless.com/).
 
+## MCP Server
+
+Use the BlueHive MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.
+
+[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=%40bluehive%2Fsdk-mcp&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBibHVlaGl2ZS9zZGstbWNwIl19)
+[![Install in VS Code](https://img.shields.io/badge/_-Add_to_VS_Code-blue?style=for-the-badge&logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA0MCA0MCI+PHBhdGggZmlsbD0iI0VFRSIgZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNMzAuMjM1IDM5Ljg4NGEyLjQ5MSAyLjQ5MSAwIDAgMS0xLjc4MS0uNzNMMTIuNyAyNC43OGwtMy40NiAyLjYyNC0zLjQwNiAyLjU4MmExLjY2NSAxLjY2NSAwIDAgMS0xLjA4Mi4zMzggMS42NjQgMS42NjQgMCAwIDEtMS4wNDYtLjQzMWwtMi4yLTJhMS42NjYgMS42NjYgMCAwIDEgMC0yLjQ2M0w3LjQ1OCAyMCA0LjY3IDE3LjQ1MyAxLjUwNyAxNC41N2ExLjY2NSAxLjY2NSAwIDAgMSAwLTIuNDYzbDIuMi0yYTEuNjY1IDEuNjY1IDAgMCAxIDIuMTMtLjA5N2w2Ljg2MyA1LjIwOUwyOC40NTIuODQ0YTIuNDg4IDIuNDg4IDAgMCAxIDEuODQxLS43MjljLjM1MS4wMDkuNjk5LjA5MSAxLjAxOS4yNDVsOC4yMzYgMy45NjFhMi41IDIuNSAwIDAgMSAxLjQxNSAyLjI1M3YuMDk5LS4wNDVWMzMuMzd2LS4wNDUuMDk1YTIuNTAxIDIuNTAxIDAgMCAxLTEuNDE2IDIuMjU3bC04LjIzNSAzLjk2MWEyLjQ5MiAyLjQ5MiAwIDAgMS0xLjA3Ny4yNDZabS43MTYtMjguOTQ3LTExLjk0OCA5LjA2MiAxMS45NTIgOS4wNjUtLjAwNC0xOC4xMjdaIi8+PC9zdmc+)](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22%40bluehive%2Fsdk-mcp%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40bluehive%2Fsdk-mcp%22%5D%7D)
+
+> Note: You may need to set environment variables in your MCP client.
+
 ## Documentation
 
 The REST API documentation can be found on [docs.bluehive.com](https://docs.bluehive.com/). The full API of this library can be found in [api.md](https://github.com/bluehive-health/bluehive-sdk-python/tree/main/api.md).
@@ -52,7 +61,7 @@ The REST API documentation can be found on [docs.bluehive.com](https://docs.blue
 
 ```sh
 # install from PyPI
-pip install --pre bluehive
+pip install '--pre bluehive'
 ```
 
 ## Usage
@@ -102,7 +111,7 @@ You can enable this by installing `aiohttp`:
 
 ```sh
 # install from PyPI
-pip install --pre bluehive[aiohttp]
+pip install '--pre bluehive[aiohttp]'
 ```
 
 Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:

{bluehive-0.1.0a20.dist-info → bluehive-0.1.0a22.dist-info}/RECORD

@@ -1,17 +1,17 @@
 bluehive/__init__.py,sha256=r7geg3adw0joOxuZsSgIeZlSQOU6ao3zkI2Rrsml6x0,2683
-bluehive/_base_client.py,sha256=FHGSOPPXSI0iBMqMUQwjAcxtiVSmvA5HmW6ZNc9qQ-c,67049
-bluehive/_client.py,sha256=rKkew9M8iyh4ydDrmqGRYxvxml86wLamHk2hwB4c3PA,19887
+bluehive/_base_client.py,sha256=DMdemJhv-oyYJJpLbhVqzX2g2XZror9Qm2ecb6QvoV4,73411
+bluehive/_client.py,sha256=suRJhomJFF8iQQEjDw41DHFiSxYoPfnwXVrBqb0oieI,28720
 bluehive/_compat.py,sha256=DQBVORjFb33zch24jzkhM14msvnzY7mmSmgDLaVFUM8,6562
 bluehive/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 bluehive/_exceptions.py,sha256=QOhLZv_tev7t7XO_pk0NoT7nzwA5VU6wtZdVWarToqo,3224
 bluehive/_files.py,sha256=KnEzGi_O756MvKyJ4fOCW_u3JhOeWPQ4RsmDvqihDQU,3545
-bluehive/_models.py,sha256=3D65psj_C02Mw0K2zpBWrn1khmrvtEXgTTQ6P4r3tUY,31837
+bluehive/_models.py,sha256=R3MpO2z4XhTAnD3ObEks32suRXleF1g7BEgQTOLIxTs,32112
 bluehive/_qs.py,sha256=craIKyvPktJ94cvf9zn8j8ekG9dWJzhWv0ob34lIOv4,4828
 bluehive/_resource.py,sha256=MI2mGktYiePpr3PUh2uCPn1ubEsju6JkKoMupdTaqtc,1112
 bluehive/_response.py,sha256=u3wZ9ksvCqcP549TZTsozw0LNZmHf1yPVWPo1hxMNDg,28800
 bluehive/_streaming.py,sha256=XdfOw0CK5YOWsYw0YebCWmglGspKi9NOzjkR3Krj9To,10229
-bluehive/_types.py,sha256=a8wHSA7q6T1mqY4qaWJYzAfVCjO6Vm8UOIgCOc4EMhQ,7297
-bluehive/_version.py,sha256=kBheHSp_qxun39gj_vErioGVAzkvcyicxv0zqmxbGHQ,169
+bluehive/_types.py,sha256=655Bwc25gjDjGefiVGfS54WqLqBGoUoa4kYqATl3Y_8,7596
+bluehive/_version.py,sha256=fTD_rB92mZAqpYt-Hgn7IGe6vDpnxIgqF6tYA7B8Llc,169
 bluehive/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bluehive/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
 bluehive/_utils/_compat.py,sha256=D8gtAvjJQrDWt9upS0XaG9Rr5l1QhiAx_I_1utT_tt0,1195
@@ -40,19 +40,19 @@ bluehive/resources/employers/__init__.py,sha256=-ovT4pUPpmcAS2DPbKjmVXA7AkTPtnYj
 bluehive/resources/employers/employers.py,sha256=y1ntoaxVC0ItOoJvJKoZFZvUlyaOSdgwnMxaKPSFhII,15415
 bluehive/resources/employers/service_bundles.py,sha256=EOKYyHZFLX_8w989a_DxLqiFrJ6mfcHNvgpW1R0LHZE,23160
 bluehive/types/__init__.py,sha256=Hi8LR0U2r8dB-9tZRTF7ar_p2sK9sYIcR_VP2HbbcuY,4051
-bluehive/types/database_check_health_response.py,sha256=zLlcDlDzrebwMLjVVwLtYLt-s9v5s-ogQoKOhLDgfeA,986
+bluehive/types/database_check_health_response.py,sha256=CUYPCysskB9HYVxuBujxPWw5Q_HYtHDCnUpg_ja2FIA,1047
 bluehive/types/employee_create_params.py,sha256=sDBBCKkTyuDobdh8aKuWo_nH1oi2PwKmS8UVkAp4KVI,1415
-bluehive/types/employee_create_response.py,sha256=8SsQXkwJvfJhcVr-ISBPskEqtptSFK8dZA6BQsrVyXE,368
-bluehive/types/employee_delete_response.py,sha256=6XPSH2M0_xfuB3MflcIGiiuZeEwIxzhqpcbcCANBY-c,236
+bluehive/types/employee_create_response.py,sha256=sAtYkDdY5XJru1K4FLp25Jig3FCoKKNXefx2fYl3WAY,409
+bluehive/types/employee_delete_response.py,sha256=tnUYLcnD5K833J0uuX9emcIX-0Ka4gWKMm96SFiqH78,277
 bluehive/types/employee_link_user_params.py,sha256=joLgsTE_AdPXnkzMvSB_9wvh0VtDBT_416PTT-m70x0,525
-bluehive/types/employee_link_user_response.py,sha256=1qtjsBJq3EVUPRa7ncka2d2sHjJzou0UIAd7m24be18,360
+bluehive/types/employee_link_user_response.py,sha256=TDxxXURT9JtdIKDdHHISsS_nijUDI_33we46WQjmhGs,400
 bluehive/types/employee_list_params.py,sha256=qQrXZb2wUxOExAYW9-yFlQGMae1OOkAOzThJRos-m7E,578
-bluehive/types/employee_list_response.py,sha256=FSHkwPzSGv0E1YHZoLAQkaXTI8ZnZZlnjHQ45v-p5kY,2738
-bluehive/types/employee_retrieve_response.py,sha256=j6gJXujtZTg2Y4kdcW1W_ZtUJAX1vCoDR0foADr1QCc,2675
+bluehive/types/employee_list_response.py,sha256=c1OjU_zIKODFf4R_gefOMdFkFsp76-AhG3Ihn4frIaE,2838
+bluehive/types/employee_retrieve_response.py,sha256=WDg66AlAgDNPSRgrI5spQlI2DuPFTha0HGts10yJRU4,2770
 bluehive/types/employee_unlink_user_params.py,sha256=avms6rnR0HiTp2C5brQsfgDP_9FvqXOBOyt4WpOdvV4,541
-bluehive/types/employee_unlink_user_response.py,sha256=UiXg_yue69NkwsnMHD6z7z3uIQW6r1wDsuCxAGK9xfA,244
+bluehive/types/employee_unlink_user_response.py,sha256=Lzgu4IJsV07UtfMTIdN9cD0dlP5XuoxXZZmRorSJP4Y,286
 bluehive/types/employee_update_params.py,sha256=dyVSS4er6Pa3fwLTgDlK3KOsRpokEMeI_L4vm1HT7dM,1409
-bluehive/types/employee_update_response.py,sha256=kQkUDxhf1dhb4WtjzDecdules-73W4ffQQQS3gA4V7c,236
+bluehive/types/employee_update_response.py,sha256=hkELB-dcMnsZihkWUZUqNABTTY9YicLiFi5-fYCbB7k,277
 bluehive/types/employer_create_params.py,sha256=DFsB8Vtaoyg8aqhvh3D877F31uSuPwP3P1ufE6imraQ,1224
 bluehive/types/employer_create_response.py,sha256=Af4aHm6Y_S2tP4o7-hKsAUl671-lKqWwrgEnj-ukfrY,815
 bluehive/types/employer_list_response.py,sha256=8PBOBuAFEUyyGhTyTu0mplilm9fbYybU2F9JT1TX2A0,252
@@ -62,7 +62,7 @@ bluehive/types/fax_retrieve_status_response.py,sha256=KU1eCgg0vvFMKLLmuUhq3KEMry
 bluehive/types/fax_send_params.py,sha256=u_mEjVxij6F0le0HCLDYOjzRgskE6O8ipwBZj6vgs-s,1136
 bluehive/types/fax_send_response.py,sha256=rv9t-MWLKKasWPETSn__QurGBXd5DWJdbAdZuQkTfH0,880
 bluehive/types/health_check_response.py,sha256=WILSpTguVO6DHPF0TK-zKx9xz5ECurna_Mu0hrQ7zK4,259
-bluehive/types/hl7_send_results_params.py,sha256=GWdDKQcMyul9jZKH6ouNJ9UIKRAzUWRXrysJsLsIMwo,703
+bluehive/types/hl7_send_results_params.py,sha256=ROC75aywYlB35oonGFng6f8k7xOPcRgudxnT6J2A8gc,742
 bluehive/types/hl7_send_results_response.py,sha256=KmOB5ULQtdPVvLu0bpiDFd8ABqygvvWx8borj9e9yGI,206
 bluehive/types/integration_check_active_response.py,sha256=-07-eOa1xFat1JcO8DE6YKNePIgIq8SC7W0CENPbDyc,233
 bluehive/types/integration_list_response.py,sha256=vx8WGfEzFBJNXPmNy9GLVkVX-3daPFAuXxZeXK8TwZI,490
@@ -91,7 +91,7 @@ bluehive/types/employers/service_bundle_list_response.py,sha256=vnZlYv7KObJ0OSSY
 bluehive/types/employers/service_bundle_retrieve_response.py,sha256=9nwdzfgErAQFzqwivKhKCLqA9k7ZsMj4YbNig09-Eho,1030
 bluehive/types/employers/service_bundle_update_params.py,sha256=gxRnvCSsBsUqi1M91nhEXgj-2l03xlrnPeXOPAQ1ujA,812
 bluehive/types/employers/service_bundle_update_response.py,sha256=zUR_nYflDEmLSmTcFb4EaTELCInqZZI-VIBHgcPq7G4,1026
-bluehive-0.1.0a20.dist-info/METADATA,sha256=6-LISRQKDTHcQrzrBSdoOedIV_X6w1e2-waK1YlXe6M,13680
-bluehive-0.1.0a20.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-bluehive-0.1.0a20.dist-info/licenses/LICENSE,sha256=Q2LP5YQQAGzyScIIkgum9Z19KCG4jZvZHMgDQ_vOOqM,11338
-bluehive-0.1.0a20.dist-info/RECORD,,
+bluehive-0.1.0a22.dist-info/METADATA,sha256=P5yy6dHadC5hqMRnwKECM99XFUlroGVhIGGb6tmQT-s,15352
+bluehive-0.1.0a22.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+bluehive-0.1.0a22.dist-info/licenses/LICENSE,sha256=ZHnXNtXLPBaOPoIsjBPGcs3xJ7n1mBEpTSXzz_4a5JY,11338
+bluehive-0.1.0a22.dist-info/RECORD,,

{bluehive-0.1.0a20.dist-info → bluehive-0.1.0a22.dist-info}/licenses/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2025 BlueHive
+   Copyright 2026 BlueHive
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.