samplehc 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

samplehc/resources/v2/ledger/{orders.py → account.py}

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
+from typing import Dict, Union
+from datetime import datetime
 
 import httpx
 
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ...._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
 from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
@@ -17,48 +18,46 @@ from ...._response import (
     async_to_streamed_response_wrapper,
 )
 from ...._base_client import make_request_options
-from ....types.v2.ledger import order_retrieve_batch_balances_params
-from ....types.v2.ledger.order_retrieve_balances_response import OrderRetrieveBalancesResponse
-from ....types.v2.ledger.order_retrieve_batch_balances_response import OrderRetrieveBatchBalancesResponse
+from ....types.v2.ledger import account_writeoff_params
+from ....types.v2.ledger.account_writeoff_response import AccountWriteoffResponse
 
-__all__ = ["OrdersResource", "AsyncOrdersResource"]
+__all__ = ["AccountResource", "AsyncAccountResource"]
 
 
-class OrdersResource(SyncAPIResource):
+class AccountResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> OrdersResourceWithRawResponse:
+    def with_raw_response(self) -> AccountResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/samplehc/samplehc-python#accessing-raw-response-data-eg-headers
         """
-        return OrdersResourceWithRawResponse(self)
+        return AccountResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> OrdersResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AccountResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/samplehc/samplehc-python#with_streaming_response
         """
-        return OrdersResourceWithStreamingResponse(self)
+        return AccountResourceWithStreamingResponse(self)
 
-    def retrieve_balances(
+    def get_balance(
         self,
-        order_id: str,
+        line_item_id: str,
         *,
+        order_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> OrderRetrieveBalancesResponse:
+    ) -> None:
         """
-        Retrieves outstanding balances for a single order ID across all balance
-        categories (order-writeoff, unallocated, institution invoices, institution
-        uninvoiced, patient responsibility).
+        Get balance for a ledger account
 
         Args:
           extra_headers: Send extra headers
@@ -71,32 +70,43 @@ class OrdersResource(SyncAPIResource):
         """
         if not order_id:
             raise ValueError(f"Expected a non-empty value for `order_id` but received {order_id!r}")
+        if not line_item_id:
+            raise ValueError(f"Expected a non-empty value for `line_item_id` but received {line_item_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._get(
-            f"/api/v2/ledger/orders/{order_id}/balances",
+            f"/api/v2/ledger/account/{order_id}/line-item/{line_item_id}/balance",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=OrderRetrieveBalancesResponse,
+            cast_to=NoneType,
         )
 
-    def retrieve_batch_balances(
+    def writeoff(
         self,
+        line_item_id: str,
         *,
-        order_ids: List[str],
+        order_id: str,
+        description: str,
+        metadata: Dict[str, object] | NotGiven = NOT_GIVEN,
+        posted_at: Union[str, datetime] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> OrderRetrieveBatchBalancesResponse:
-        """
-        Retrieves outstanding balances for an array of order IDs across all balance
-        categories (order-writeoff, unallocated, institution invoices, institution
-        uninvoiced, patient responsibility).
+    ) -> AccountWriteoffResponse:
+        """Writes off the remaining balance in an account on the ledger.
+
+        Throws an error if
+        the account contains a non-positive balance.
 
         Args:
-          order_ids: Array of order IDs to retrieve balances for (max 100)
+          description: The description of the write-off.
+
+          metadata: Any optional metadata to associate with the write-off.
+
+          posted_at: The date and time to post the write-off.
 
           extra_headers: Send extra headers
 
@@ -106,53 +116,61 @@ class OrdersResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        if not order_id:
+            raise ValueError(f"Expected a non-empty value for `order_id` but received {order_id!r}")
+        if not line_item_id:
+            raise ValueError(f"Expected a non-empty value for `line_item_id` but received {line_item_id!r}")
         return self._post(
-            "/api/v2/ledger/orders/batch-balances",
+            f"/api/v2/ledger/account/{order_id}/line-item/{line_item_id}/writeoff",
             body=maybe_transform(
-                {"order_ids": order_ids}, order_retrieve_batch_balances_params.OrderRetrieveBatchBalancesParams
+                {
+                    "description": description,
+                    "metadata": metadata,
+                    "posted_at": posted_at,
+                },
+                account_writeoff_params.AccountWriteoffParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=OrderRetrieveBatchBalancesResponse,
+            cast_to=AccountWriteoffResponse,
         )
 
 
-class AsyncOrdersResource(AsyncAPIResource):
+class AsyncAccountResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncOrdersResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncAccountResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/samplehc/samplehc-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncOrdersResourceWithRawResponse(self)
+        return AsyncAccountResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncOrdersResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncAccountResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/samplehc/samplehc-python#with_streaming_response
         """
-        return AsyncOrdersResourceWithStreamingResponse(self)
+        return AsyncAccountResourceWithStreamingResponse(self)
 
-    async def retrieve_balances(
+    async def get_balance(
         self,
-        order_id: str,
+        line_item_id: str,
         *,
+        order_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> OrderRetrieveBalancesResponse:
+    ) -> None:
         """
-        Retrieves outstanding balances for a single order ID across all balance
-        categories (order-writeoff, unallocated, institution invoices, institution
-        uninvoiced, patient responsibility).
+        Get balance for a ledger account
 
         Args:
           extra_headers: Send extra headers
@@ -165,32 +183,43 @@ class AsyncOrdersResource(AsyncAPIResource):
         """
         if not order_id:
             raise ValueError(f"Expected a non-empty value for `order_id` but received {order_id!r}")
+        if not line_item_id:
+            raise ValueError(f"Expected a non-empty value for `line_item_id` but received {line_item_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._get(
-            f"/api/v2/ledger/orders/{order_id}/balances",
+            f"/api/v2/ledger/account/{order_id}/line-item/{line_item_id}/balance",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=OrderRetrieveBalancesResponse,
+            cast_to=NoneType,
         )
 
-    async def retrieve_batch_balances(
+    async def writeoff(
         self,
+        line_item_id: str,
         *,
-        order_ids: List[str],
+        order_id: str,
+        description: str,
+        metadata: Dict[str, object] | NotGiven = NOT_GIVEN,
+        posted_at: Union[str, datetime] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> OrderRetrieveBatchBalancesResponse:
-        """
-        Retrieves outstanding balances for an array of order IDs across all balance
-        categories (order-writeoff, unallocated, institution invoices, institution
-        uninvoiced, patient responsibility).
+    ) -> AccountWriteoffResponse:
+        """Writes off the remaining balance in an account on the ledger.
+
+        Throws an error if
+        the account contains a non-positive balance.
 
         Args:
-          order_ids: Array of order IDs to retrieve balances for (max 100)
+          description: The description of the write-off.
+
+          metadata: Any optional metadata to associate with the write-off.
+
+          posted_at: The date and time to post the write-off.
 
           extra_headers: Send extra headers
 
@@ -200,61 +229,70 @@ class AsyncOrdersResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        if not order_id:
+            raise ValueError(f"Expected a non-empty value for `order_id` but received {order_id!r}")
+        if not line_item_id:
+            raise ValueError(f"Expected a non-empty value for `line_item_id` but received {line_item_id!r}")
         return await self._post(
-            "/api/v2/ledger/orders/batch-balances",
+            f"/api/v2/ledger/account/{order_id}/line-item/{line_item_id}/writeoff",
             body=await async_maybe_transform(
-                {"order_ids": order_ids}, order_retrieve_batch_balances_params.OrderRetrieveBatchBalancesParams
+                {
+                    "description": description,
+                    "metadata": metadata,
+                    "posted_at": posted_at,
+                },
+                account_writeoff_params.AccountWriteoffParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=OrderRetrieveBatchBalancesResponse,
+            cast_to=AccountWriteoffResponse,
         )
 
 
-class OrdersResourceWithRawResponse:
-    def __init__(self, orders: OrdersResource) -> None:
-        self._orders = orders
+class AccountResourceWithRawResponse:
+    def __init__(self, account: AccountResource) -> None:
+        self._account = account
 
-        self.retrieve_balances = to_raw_response_wrapper(
-            orders.retrieve_balances,
+        self.get_balance = to_raw_response_wrapper(
+            account.get_balance,
         )
-        self.retrieve_batch_balances = to_raw_response_wrapper(
-            orders.retrieve_batch_balances,
+        self.writeoff = to_raw_response_wrapper(
+            account.writeoff,
         )
 
 
-class AsyncOrdersResourceWithRawResponse:
-    def __init__(self, orders: AsyncOrdersResource) -> None:
-        self._orders = orders
+class AsyncAccountResourceWithRawResponse:
+    def __init__(self, account: AsyncAccountResource) -> None:
+        self._account = account
 
-        self.retrieve_balances = async_to_raw_response_wrapper(
-            orders.retrieve_balances,
+        self.get_balance = async_to_raw_response_wrapper(
+            account.get_balance,
         )
-        self.retrieve_batch_balances = async_to_raw_response_wrapper(
-            orders.retrieve_batch_balances,
+        self.writeoff = async_to_raw_response_wrapper(
+            account.writeoff,
         )
 
 
-class OrdersResourceWithStreamingResponse:
-    def __init__(self, orders: OrdersResource) -> None:
-        self._orders = orders
+class AccountResourceWithStreamingResponse:
+    def __init__(self, account: AccountResource) -> None:
+        self._account = account
 
-        self.retrieve_balances = to_streamed_response_wrapper(
-            orders.retrieve_balances,
+        self.get_balance = to_streamed_response_wrapper(
+            account.get_balance,
         )
-        self.retrieve_batch_balances = to_streamed_response_wrapper(
-            orders.retrieve_batch_balances,
+        self.writeoff = to_streamed_response_wrapper(
+            account.writeoff,
         )
 
 
-class AsyncOrdersResourceWithStreamingResponse:
-    def __init__(self, orders: AsyncOrdersResource) -> None:
-        self._orders = orders
+class AsyncAccountResourceWithStreamingResponse:
+    def __init__(self, account: AsyncAccountResource) -> None:
+        self._account = account
 
-        self.retrieve_balances = async_to_streamed_response_wrapper(
-            orders.retrieve_balances,
+        self.get_balance = async_to_streamed_response_wrapper(
+            account.get_balance,
         )
-        self.retrieve_batch_balances = async_to_streamed_response_wrapper(
-            orders.retrieve_batch_balances,
+        self.writeoff = async_to_streamed_response_wrapper(
+            account.writeoff,
         )