lark-billing 0.5.0__py3-none-any.whl

lark/resources/usage_events.py

@@ -0,0 +1,221 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union
+from datetime import datetime
+
+import httpx
+
+from ..types import usage_event_create_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
+
+__all__ = ["UsageEventsResource", "AsyncUsageEventsResource"]
+
+
+class UsageEventsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> UsageEventsResourceWithRawResponse:
+        """
+        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 UsageEventsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> UsageEventsResourceWithStreamingResponse:
+        """
+        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 UsageEventsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        data: Dict[str, Union[str, int]],
+        event_name: str,
+        idempotency_key: str,
+        subject_id: str,
+        timestamp: Union[str, datetime, None] | 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,
+    ) -> object:
+        """Create Usage Event
+
+        Args:
+          data: The data of the usage event.
+
+        This should contain any data that is needed to
+              aggregate the usage event.
+
+          event_name: The name of the event. This is used by pricing metrics to aggregate usage
+              events.
+
+          idempotency_key: The idempotency key for the usage event. This ensures that the same event is not
+              processed multiple times.
+
+          subject_id: The ID or external ID of the subject that the usage event is for.
+
+          timestamp: The timestamp of the usage event. It is highly recommended to provide a
+              timestamp. If not provided, the current timestamp will be used.
+
+          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(
+            "/usage-events",
+            body=maybe_transform(
+                {
+                    "data": data,
+                    "event_name": event_name,
+                    "idempotency_key": idempotency_key,
+                    "subject_id": subject_id,
+                    "timestamp": timestamp,
+                },
+                usage_event_create_params.UsageEventCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=object,
+        )
+
+
+class AsyncUsageEventsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncUsageEventsResourceWithRawResponse:
+        """
+        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 AsyncUsageEventsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncUsageEventsResourceWithStreamingResponse:
+        """
+        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 AsyncUsageEventsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        data: Dict[str, Union[str, int]],
+        event_name: str,
+        idempotency_key: str,
+        subject_id: str,
+        timestamp: Union[str, datetime, None] | 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,
+    ) -> object:
+        """Create Usage Event
+
+        Args:
+          data: The data of the usage event.
+
+        This should contain any data that is needed to
+              aggregate the usage event.
+
+          event_name: The name of the event. This is used by pricing metrics to aggregate usage
+              events.
+
+          idempotency_key: The idempotency key for the usage event. This ensures that the same event is not
+              processed multiple times.
+
+          subject_id: The ID or external ID of the subject that the usage event is for.
+
+          timestamp: The timestamp of the usage event. It is highly recommended to provide a
+              timestamp. If not provided, the current timestamp will be used.
+
+          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(
+            "/usage-events",
+            body=await async_maybe_transform(
+                {
+                    "data": data,
+                    "event_name": event_name,
+                    "idempotency_key": idempotency_key,
+                    "subject_id": subject_id,
+                    "timestamp": timestamp,
+                },
+                usage_event_create_params.UsageEventCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=object,
+        )
+
+
+class UsageEventsResourceWithRawResponse:
+    def __init__(self, usage_events: UsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.create = to_raw_response_wrapper(
+            usage_events.create,
+        )
+
+
+class AsyncUsageEventsResourceWithRawResponse:
+    def __init__(self, usage_events: AsyncUsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.create = async_to_raw_response_wrapper(
+            usage_events.create,
+        )
+
+
+class UsageEventsResourceWithStreamingResponse:
+    def __init__(self, usage_events: UsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.create = to_streamed_response_wrapper(
+            usage_events.create,
+        )
+
+
+class AsyncUsageEventsResourceWithStreamingResponse:
+    def __init__(self, usage_events: AsyncUsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.create = async_to_streamed_response_wrapper(
+            usage_events.create,
+        )

lark/types/__init__.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .period import Period as Period
+from .period_param import PeriodParam as PeriodParam
+from .amount_output import AmountOutput as AmountOutput
+from .subject_resource import SubjectResource as SubjectResource
+from .flat_price_output import FlatPriceOutput as FlatPriceOutput
+from .amount_input_param import AmountInputParam as AmountInputParam
+from .rate_card_resource import RateCardResource as RateCardResource
+from .invoice_list_params import InvoiceListParams as InvoiceListParams
+from .subject_list_params import SubjectListParams as SubjectListParams
+from .package_price_output import PackagePriceOutput as PackagePriceOutput
+from .invoice_list_response import InvoiceListResponse as InvoiceListResponse
+from .rate_card_list_params import RateCardListParams as RateCardListParams
+from .subject_create_params import SubjectCreateParams as SubjectCreateParams
+from .subject_list_response import SubjectListResponse as SubjectListResponse
+from .subject_update_params import SubjectUpdateParams as SubjectUpdateParams
+from .subscription_resource import SubscriptionResource as SubscriptionResource
+from .flat_price_input_param import FlatPriceInputParam as FlatPriceInputParam
+from .checkout_callback_param import CheckoutCallbackParam as CheckoutCallbackParam
+from .pricing_metric_resource import PricingMetricResource as PricingMetricResource
+from .rate_card_create_params import RateCardCreateParams as RateCardCreateParams
+from .rate_card_list_response import RateCardListResponse as RateCardListResponse
+from .subject_create_response import SubjectCreateResponse as SubjectCreateResponse
+from .subscription_list_params import SubscriptionListParams as SubscriptionListParams
+from .package_price_input_param import PackagePriceInputParam as PackagePriceInputParam
+from .usage_event_create_params import UsageEventCreateParams as UsageEventCreateParams
+from .pricing_metric_list_params import PricingMetricListParams as PricingMetricListParams
+from .subscription_cancel_params import SubscriptionCancelParams as SubscriptionCancelParams
+from .subscription_create_params import SubscriptionCreateParams as SubscriptionCreateParams
+from .subscription_list_response import SubscriptionListResponse as SubscriptionListResponse
+from .pricing_metric_create_params import PricingMetricCreateParams as PricingMetricCreateParams
+from .pricing_metric_list_response import PricingMetricListResponse as PricingMetricListResponse
+from .subscription_create_response import SubscriptionCreateResponse as SubscriptionCreateResponse
+from .pricing_metric_create_summary_params import PricingMetricCreateSummaryParams as PricingMetricCreateSummaryParams
+from .subscription_change_rate_card_params import SubscriptionChangeRateCardParams as SubscriptionChangeRateCardParams
+from .customer_portal_create_session_params import (
+    CustomerPortalCreateSessionParams as CustomerPortalCreateSessionParams,
+)
+from .pricing_metric_create_summary_response import (
+    PricingMetricCreateSummaryResponse as PricingMetricCreateSummaryResponse,
+)
+from .subscription_change_rate_card_response import (
+    SubscriptionChangeRateCardResponse as SubscriptionChangeRateCardResponse,
+)
+from .customer_portal_create_session_response import (
+    CustomerPortalCreateSessionResponse as CustomerPortalCreateSessionResponse,
+)
+from .customer_access_retrieve_billing_state_response import (
+    CustomerAccessRetrieveBillingStateResponse as CustomerAccessRetrieveBillingStateResponse,
+)

lark/types/amount_input_param.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Required, TypedDict
+
+__all__ = ["AmountInputParam"]
+
+
+class AmountInputParam(TypedDict, total=False):
+    currency_code: Required[str]
+    """The currency code of the amount."""
+
+    value: Required[Union[float, str]]
+    """The value of the amount in the smallest unit of the currency."""

lark/types/amount_output.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["AmountOutput"]
+
+
+class AmountOutput(BaseModel):
+    currency_code: str
+    """The currency code of the amount."""
+
+    value: str
+    """The value of the amount in the smallest unit of the currency."""

lark/types/checkout_callback_param.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["CheckoutCallbackParam"]
+
+
+class CheckoutCallbackParam(TypedDict, total=False):
+    cancelled_url: Required[str]
+    """The URL to redirect to after the checkout is cancelled."""
+
+    success_url: Required[str]
+    """The URL to redirect to after the checkout is successful."""

lark/types/customer_access_retrieve_billing_state_response.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .._models import BaseModel
+
+__all__ = ["CustomerAccessRetrieveBillingStateResponse", "ActiveSubscription", "UsageData"]
+
+
+class ActiveSubscription(BaseModel):
+    rate_card_id: str
+
+    subscription_id: str
+
+
+class UsageData(BaseModel):
+    included_units: int
+
+    pricing_metric_id: str
+
+    rate_name: str
+
+    used_units: str
+
+
+class CustomerAccessRetrieveBillingStateResponse(BaseModel):
+    active_subscriptions: List[ActiveSubscription]
+    """List of active subscriptions the subject is subscribed to."""
+
+    has_active_subscription: bool
+    """Whether the subject has an active subscription."""
+
+    has_overage_for_usage: bool
+    """
+    Whether the subject has exceeded the included usage (if any) on a usage-based
+    rate they are subscribed to.
+    """
+
+    usage_data: List[UsageData]
+    """The usage data for the usage-based rates the subject is subscribed to."""

lark/types/customer_portal_create_session_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["CustomerPortalCreateSessionParams"]
+
+
+class CustomerPortalCreateSessionParams(TypedDict, total=False):
+    return_url: Required[str]
+    """
+    The URL to redirect customers to if they click the back button on the customer
+    portal.
+    """
+
+    subject_id: Required[str]
+    """The ID or external ID of the subject to create the customer portal session for."""

lark/types/customer_portal_create_session_response.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["CustomerPortalCreateSessionResponse"]
+
+
+class CustomerPortalCreateSessionResponse(BaseModel):
+    expires_at: datetime
+    """The date and time the customer portal session expires."""
+
+    subject_id: str
+    """The ID of the subject for the customer portal session."""
+
+    url: str
+    """The URL to redirect to the customer portal session."""

lark/types/flat_price_input_param.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .amount_input_param import AmountInputParam
+
+__all__ = ["FlatPriceInputParam"]
+
+
+class FlatPriceInputParam(TypedDict, total=False):
+    """Flat price is a price that linearly scales with the quantity."""
+
+    amount: Required[AmountInputParam]
+
+    price_type: Literal["flat"]

lark/types/flat_price_output.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .amount_output import AmountOutput
+
+__all__ = ["FlatPriceOutput"]
+
+
+class FlatPriceOutput(BaseModel):
+    """Flat price is a price that linearly scales with the quantity."""
+
+    amount: AmountOutput
+
+    price_type: Optional[Literal["flat"]] = None

lark/types/invoice_list_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["InvoiceListParams"]
+
+
+class InvoiceListParams(TypedDict, total=False):
+    subject_id: Required[str]
+    """The ID or external ID of the subject to list invoices for."""
+
+    limit: int
+
+    offset: int

lark/types/invoice_list_response.py

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .amount_output import AmountOutput
+
+__all__ = ["InvoiceListResponse", "Invoice", "InvoiceLineItem"]
+
+
+class InvoiceLineItem(BaseModel):
+    amount: AmountOutput
+
+    description: str
+
+    price_in_unit_amount: AmountOutput
+
+    quantity: int
+
+
+class Invoice(BaseModel):
+    id: str
+    """The ID of the invoice."""
+
+    created_at: datetime
+    """The date and time the invoice was created."""
+
+    hosted_url: Optional[str] = None
+    """The URL of the hosted invoice."""
+
+    line_items: List[InvoiceLineItem]
+    """The line items of the invoice."""
+
+    status: Literal["draft", "open", "paid", "uncollectible", "void"]
+    """The status of the invoice."""
+
+    subject_id: str
+    """The ID of the subject for the invoice."""
+
+    total_amount: AmountOutput
+    """The total amount of the invoice."""
+
+
+class InvoiceListResponse(BaseModel):
+    has_more: bool
+
+    invoices: List[Invoice]

lark/types/package_price_input_param.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .amount_input_param import AmountInputParam
+
+__all__ = ["PackagePriceInputParam"]
+
+
+class PackagePriceInputParam(TypedDict, total=False):
+    """Package price is a price that is charged for a fixed number of units.
+
+    For example, $10 per 1000 units. If the quantity is not a multiple of the package units, the rounding behavior will be applied.
+    """
+
+    amount: Required[AmountInputParam]
+
+    package_units: Required[int]
+
+    rounding_behavior: Required[Literal["round_up", "round_down"]]
+
+    price_type: Literal["package"]

lark/types/package_price_output.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .amount_output import AmountOutput
+
+__all__ = ["PackagePriceOutput"]
+
+
+class PackagePriceOutput(BaseModel):
+    """Package price is a price that is charged for a fixed number of units.
+
+    For example, $10 per 1000 units. If the quantity is not a multiple of the package units, the rounding behavior will be applied.
+    """
+
+    amount: AmountOutput
+
+    package_units: int
+
+    rounding_behavior: Literal["round_up", "round_down"]
+
+    price_type: Optional[Literal["package"]] = None

lark/types/period.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["Period"]
+
+
+class Period(BaseModel):
+    end: datetime
+
+    start: datetime
+
+    inclusive_end: Optional[bool] = None
+
+    inclusive_start: Optional[bool] = None

lark/types/period_param.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["PeriodParam"]
+
+
+class PeriodParam(TypedDict, total=False):
+    end: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+
+    start: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+
+    inclusive_end: bool
+
+    inclusive_start: bool