lark-billing 0.5.0__py3-none-any.whl

lark/resources/customer_access.py

@@ -0,0 +1,167 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .._types import Body, Query, Headers, NotGiven, not_given
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.customer_access_retrieve_billing_state_response import CustomerAccessRetrieveBillingStateResponse
+
+__all__ = ["CustomerAccessResource", "AsyncCustomerAccessResource"]
+
+
+class CustomerAccessResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CustomerAccessResourceWithRawResponse:
+        """
+        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/uselark/lark-billing-python#accessing-raw-response-data-eg-headers
+        """
+        return CustomerAccessResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CustomerAccessResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/uselark/lark-billing-python#with_streaming_response
+        """
+        return CustomerAccessResourceWithStreamingResponse(self)
+
+    def retrieve_billing_state(
+        self,
+        subject_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,
+    ) -> CustomerAccessRetrieveBillingStateResponse:
+        """
+        Get Billing State
+
+        Args:
+          subject_id: The ID or external ID of the subject to get billing state for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not subject_id:
+            raise ValueError(f"Expected a non-empty value for `subject_id` but received {subject_id!r}")
+        return self._get(
+            f"/customer-access/{subject_id}/billing-state",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CustomerAccessRetrieveBillingStateResponse,
+        )
+
+
+class AsyncCustomerAccessResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCustomerAccessResourceWithRawResponse:
+        """
+        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/uselark/lark-billing-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCustomerAccessResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCustomerAccessResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/uselark/lark-billing-python#with_streaming_response
+        """
+        return AsyncCustomerAccessResourceWithStreamingResponse(self)
+
+    async def retrieve_billing_state(
+        self,
+        subject_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,
+    ) -> CustomerAccessRetrieveBillingStateResponse:
+        """
+        Get Billing State
+
+        Args:
+          subject_id: The ID or external ID of the subject to get billing state for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not subject_id:
+            raise ValueError(f"Expected a non-empty value for `subject_id` but received {subject_id!r}")
+        return await self._get(
+            f"/customer-access/{subject_id}/billing-state",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CustomerAccessRetrieveBillingStateResponse,
+        )
+
+
+class CustomerAccessResourceWithRawResponse:
+    def __init__(self, customer_access: CustomerAccessResource) -> None:
+        self._customer_access = customer_access
+
+        self.retrieve_billing_state = to_raw_response_wrapper(
+            customer_access.retrieve_billing_state,
+        )
+
+
+class AsyncCustomerAccessResourceWithRawResponse:
+    def __init__(self, customer_access: AsyncCustomerAccessResource) -> None:
+        self._customer_access = customer_access
+
+        self.retrieve_billing_state = async_to_raw_response_wrapper(
+            customer_access.retrieve_billing_state,
+        )
+
+
+class CustomerAccessResourceWithStreamingResponse:
+    def __init__(self, customer_access: CustomerAccessResource) -> None:
+        self._customer_access = customer_access
+
+        self.retrieve_billing_state = to_streamed_response_wrapper(
+            customer_access.retrieve_billing_state,
+        )
+
+
+class AsyncCustomerAccessResourceWithStreamingResponse:
+    def __init__(self, customer_access: AsyncCustomerAccessResource) -> None:
+        self._customer_access = customer_access
+
+        self.retrieve_billing_state = async_to_streamed_response_wrapper(
+            customer_access.retrieve_billing_state,
+        )

lark/resources/customer_portal.py

@@ -0,0 +1,187 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import customer_portal_create_session_params
+from .._types import Body, Query, Headers, NotGiven, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.customer_portal_create_session_response import CustomerPortalCreateSessionResponse
+
+__all__ = ["CustomerPortalResource", "AsyncCustomerPortalResource"]
+
+
+class CustomerPortalResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CustomerPortalResourceWithRawResponse:
+        """
+        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/uselark/lark-billing-python#accessing-raw-response-data-eg-headers
+        """
+        return CustomerPortalResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CustomerPortalResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/uselark/lark-billing-python#with_streaming_response
+        """
+        return CustomerPortalResourceWithStreamingResponse(self)
+
+    def create_session(
+        self,
+        *,
+        return_url: str,
+        subject_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,
+    ) -> CustomerPortalCreateSessionResponse:
+        """
+        Create Customer Portal Session
+
+        Args:
+          return_url: The URL to redirect customers to if they click the back button on the customer
+              portal.
+
+          subject_id: The ID or external ID of the subject to create the customer portal session for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/customer-portal/sessions",
+            body=maybe_transform(
+                {
+                    "return_url": return_url,
+                    "subject_id": subject_id,
+                },
+                customer_portal_create_session_params.CustomerPortalCreateSessionParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CustomerPortalCreateSessionResponse,
+        )
+
+
+class AsyncCustomerPortalResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCustomerPortalResourceWithRawResponse:
+        """
+        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/uselark/lark-billing-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCustomerPortalResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCustomerPortalResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/uselark/lark-billing-python#with_streaming_response
+        """
+        return AsyncCustomerPortalResourceWithStreamingResponse(self)
+
+    async def create_session(
+        self,
+        *,
+        return_url: str,
+        subject_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,
+    ) -> CustomerPortalCreateSessionResponse:
+        """
+        Create Customer Portal Session
+
+        Args:
+          return_url: The URL to redirect customers to if they click the back button on the customer
+              portal.
+
+          subject_id: The ID or external ID of the subject to create the customer portal session for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/customer-portal/sessions",
+            body=await async_maybe_transform(
+                {
+                    "return_url": return_url,
+                    "subject_id": subject_id,
+                },
+                customer_portal_create_session_params.CustomerPortalCreateSessionParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CustomerPortalCreateSessionResponse,
+        )
+
+
+class CustomerPortalResourceWithRawResponse:
+    def __init__(self, customer_portal: CustomerPortalResource) -> None:
+        self._customer_portal = customer_portal
+
+        self.create_session = to_raw_response_wrapper(
+            customer_portal.create_session,
+        )
+
+
+class AsyncCustomerPortalResourceWithRawResponse:
+    def __init__(self, customer_portal: AsyncCustomerPortalResource) -> None:
+        self._customer_portal = customer_portal
+
+        self.create_session = async_to_raw_response_wrapper(
+            customer_portal.create_session,
+        )
+
+
+class CustomerPortalResourceWithStreamingResponse:
+    def __init__(self, customer_portal: CustomerPortalResource) -> None:
+        self._customer_portal = customer_portal
+
+        self.create_session = to_streamed_response_wrapper(
+            customer_portal.create_session,
+        )
+
+
+class AsyncCustomerPortalResourceWithStreamingResponse:
+    def __init__(self, customer_portal: AsyncCustomerPortalResource) -> None:
+        self._customer_portal = customer_portal
+
+        self.create_session = async_to_streamed_response_wrapper(
+            customer_portal.create_session,
+        )

lark/resources/invoices.py

@@ -0,0 +1,191 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import invoice_list_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.invoice_list_response import InvoiceListResponse
+
+__all__ = ["InvoicesResource", "AsyncInvoicesResource"]
+
+
+class InvoicesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> InvoicesResourceWithRawResponse:
+        """
+        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/uselark/lark-billing-python#accessing-raw-response-data-eg-headers
+        """
+        return InvoicesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> InvoicesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/uselark/lark-billing-python#with_streaming_response
+        """
+        return InvoicesResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        subject_id: str,
+        limit: int | Omit = omit,
+        offset: int | Omit = omit,
+        # 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,
+    ) -> InvoiceListResponse:
+        """
+        List Invoices
+
+        Args:
+          subject_id: The ID or external ID of the subject to list invoices for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get(
+            "/invoices",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "subject_id": subject_id,
+                        "limit": limit,
+                        "offset": offset,
+                    },
+                    invoice_list_params.InvoiceListParams,
+                ),
+            ),
+            cast_to=InvoiceListResponse,
+        )
+
+
+class AsyncInvoicesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncInvoicesResourceWithRawResponse:
+        """
+        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/uselark/lark-billing-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncInvoicesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncInvoicesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/uselark/lark-billing-python#with_streaming_response
+        """
+        return AsyncInvoicesResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        subject_id: str,
+        limit: int | Omit = omit,
+        offset: int | Omit = omit,
+        # 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,
+    ) -> InvoiceListResponse:
+        """
+        List Invoices
+
+        Args:
+          subject_id: The ID or external ID of the subject to list invoices for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._get(
+            "/invoices",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "subject_id": subject_id,
+                        "limit": limit,
+                        "offset": offset,
+                    },
+                    invoice_list_params.InvoiceListParams,
+                ),
+            ),
+            cast_to=InvoiceListResponse,
+        )
+
+
+class InvoicesResourceWithRawResponse:
+    def __init__(self, invoices: InvoicesResource) -> None:
+        self._invoices = invoices
+
+        self.list = to_raw_response_wrapper(
+            invoices.list,
+        )
+
+
+class AsyncInvoicesResourceWithRawResponse:
+    def __init__(self, invoices: AsyncInvoicesResource) -> None:
+        self._invoices = invoices
+
+        self.list = async_to_raw_response_wrapper(
+            invoices.list,
+        )
+
+
+class InvoicesResourceWithStreamingResponse:
+    def __init__(self, invoices: InvoicesResource) -> None:
+        self._invoices = invoices
+
+        self.list = to_streamed_response_wrapper(
+            invoices.list,
+        )
+
+
+class AsyncInvoicesResourceWithStreamingResponse:
+    def __init__(self, invoices: AsyncInvoicesResource) -> None:
+        self._invoices = invoices
+
+        self.list = async_to_streamed_response_wrapper(
+            invoices.list,
+        )