dodopayments 1.51.0__py3-none-any.whl → 1.52.4__py3-none-any.whl

dodopayments/resources/usage_events.py

@@ -0,0 +1,597 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from datetime import datetime
+
+import httpx
+
+from ..types import usage_event_list_params, usage_event_ingest_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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 ..pagination import SyncDefaultPageNumberPagination, AsyncDefaultPageNumberPagination
+from ..types.event import Event
+from .._base_client import AsyncPaginator, make_request_options
+from ..types.event_input_param import EventInputParam
+from ..types.usage_event_ingest_response import UsageEventIngestResponse
+
+__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/dodopayments/dodopayments-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/dodopayments/dodopayments-python#with_streaming_response
+        """
+        return UsageEventsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        event_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,
+    ) -> Event:
+        """Fetch detailed information about a single event using its unique event ID.
+
+        This
+        endpoint is useful for:
+
+        - Debugging specific event ingestion issues
+        - Retrieving event details for customer support
+        - Validating that events were processed correctly
+        - Getting the complete metadata for an event
+
+        ## Event ID Format:
+
+        The event ID should be the same value that was provided during event ingestion
+        via the `/events/ingest` endpoint. Event IDs are case-sensitive and must match
+        exactly.
+
+        ## Response Details:
+
+        The response includes all event data including:
+
+        - Complete metadata key-value pairs
+        - Original timestamp (preserved from ingestion)
+        - Customer and business association
+        - Event name and processing information
+
+        ## Example Usage:
+
+        ```text
+        GET /events/api_call_12345
+        ```
+
+        Args:
+          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 event_id:
+            raise ValueError(f"Expected a non-empty value for `event_id` but received {event_id!r}")
+        return self._get(
+            f"/events/{event_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Event,
+        )
+
+    def list(
+        self,
+        *,
+        customer_id: str | NotGiven = NOT_GIVEN,
+        end: Union[str, datetime] | NotGiven = NOT_GIVEN,
+        event_name: str | NotGiven = NOT_GIVEN,
+        meter_id: str | NotGiven = NOT_GIVEN,
+        page_number: int | NotGiven = NOT_GIVEN,
+        page_size: int | NotGiven = NOT_GIVEN,
+        start: 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,
+    ) -> SyncDefaultPageNumberPagination[Event]:
+        """Fetch events from your account with powerful filtering capabilities.
+
+        This
+        endpoint is ideal for:
+
+        - Debugging event ingestion issues
+        - Analyzing customer usage patterns
+        - Building custom analytics dashboards
+        - Auditing billing-related events
+
+        ## Filtering Options:
+
+        - **Customer filtering**: Filter by specific customer ID
+        - **Event name filtering**: Filter by event type/name
+        - **Meter-based filtering**: Use a meter ID to apply the meter's event name and
+          filter criteria automatically
+        - **Time range filtering**: Filter events within a specific date range
+        - **Pagination**: Navigate through large result sets
+
+        ## Meter Integration:
+
+        When using `meter_id`, the endpoint automatically applies:
+
+        - The meter's configured `event_name` filter
+        - The meter's custom filter criteria (if any)
+        - If you also provide `event_name`, it must match the meter's event name
+
+        ## Example Queries:
+
+        - Get all events for a customer: `?customer_id=cus_abc123`
+        - Get API request events: `?event_name=api_request`
+        - Get events from last 24 hours:
+          `?start=2024-01-14T10:30:00Z&end=2024-01-15T10:30:00Z`
+        - Get events with meter filtering: `?meter_id=mtr_xyz789`
+        - Paginate results: `?page_size=50&page_number=2`
+
+        Args:
+          customer_id: Filter events by customer ID
+
+          end: Filter events created before this timestamp
+
+          event_name: Filter events by event name. If both event_name and meter_id are provided, they
+              must match the meter's configured event_name
+
+          meter_id: Filter events by meter ID. When provided, only events that match the meter's
+              event_name and filter criteria will be returned
+
+          page_number: Page number (0-based, default: 0)
+
+          page_size: Number of events to return per page (default: 10)
+
+          start: Filter events created after this timestamp
+
+          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_api_list(
+            "/events",
+            page=SyncDefaultPageNumberPagination[Event],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "customer_id": customer_id,
+                        "end": end,
+                        "event_name": event_name,
+                        "meter_id": meter_id,
+                        "page_number": page_number,
+                        "page_size": page_size,
+                        "start": start,
+                    },
+                    usage_event_list_params.UsageEventListParams,
+                ),
+            ),
+            model=Event,
+        )
+
+    def ingest(
+        self,
+        *,
+        events: Iterable[EventInputParam],
+        # 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,
+    ) -> UsageEventIngestResponse:
+        """
+        This endpoint allows you to ingest custom events that can be used for:
+
+        - Usage-based billing and metering
+        - Analytics and reporting
+        - Customer behavior tracking
+
+        ## Important Notes:
+
+        - **Duplicate Prevention**:
+          - Duplicate `event_id` values within the same request are rejected (entire
+            request fails)
+          - Subsequent requests with existing `event_id` values are ignored (idempotent
+            behavior)
+        - **Rate Limiting**: Maximum 1000 events per request
+        - **Time Validation**: Events with timestamps older than 1 hour or more than 5
+          minutes in the future will be rejected
+        - **Metadata Limits**: Maximum 50 key-value pairs per event, keys max 100 chars,
+          values max 500 chars
+
+        ## Example Usage:
+
+        ```json
+        {
+          "events": [
+            {
+              "event_id": "api_call_12345",
+              "customer_id": "cus_abc123",
+              "event_name": "api_request",
+              "timestamp": "2024-01-15T10:30:00Z",
+              "metadata": {
+                "endpoint": "/api/v1/users",
+                "method": "GET",
+                "tokens_used": "150"
+              }
+            }
+          ]
+        }
+        ```
+
+        Args:
+          events: List of events to be pushed
+
+          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(
+            "/events/ingest",
+            body=maybe_transform({"events": events}, usage_event_ingest_params.UsageEventIngestParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=UsageEventIngestResponse,
+        )
+
+
+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/dodopayments/dodopayments-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/dodopayments/dodopayments-python#with_streaming_response
+        """
+        return AsyncUsageEventsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        event_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,
+    ) -> Event:
+        """Fetch detailed information about a single event using its unique event ID.
+
+        This
+        endpoint is useful for:
+
+        - Debugging specific event ingestion issues
+        - Retrieving event details for customer support
+        - Validating that events were processed correctly
+        - Getting the complete metadata for an event
+
+        ## Event ID Format:
+
+        The event ID should be the same value that was provided during event ingestion
+        via the `/events/ingest` endpoint. Event IDs are case-sensitive and must match
+        exactly.
+
+        ## Response Details:
+
+        The response includes all event data including:
+
+        - Complete metadata key-value pairs
+        - Original timestamp (preserved from ingestion)
+        - Customer and business association
+        - Event name and processing information
+
+        ## Example Usage:
+
+        ```text
+        GET /events/api_call_12345
+        ```
+
+        Args:
+          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 event_id:
+            raise ValueError(f"Expected a non-empty value for `event_id` but received {event_id!r}")
+        return await self._get(
+            f"/events/{event_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Event,
+        )
+
+    def list(
+        self,
+        *,
+        customer_id: str | NotGiven = NOT_GIVEN,
+        end: Union[str, datetime] | NotGiven = NOT_GIVEN,
+        event_name: str | NotGiven = NOT_GIVEN,
+        meter_id: str | NotGiven = NOT_GIVEN,
+        page_number: int | NotGiven = NOT_GIVEN,
+        page_size: int | NotGiven = NOT_GIVEN,
+        start: 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,
+    ) -> AsyncPaginator[Event, AsyncDefaultPageNumberPagination[Event]]:
+        """Fetch events from your account with powerful filtering capabilities.
+
+        This
+        endpoint is ideal for:
+
+        - Debugging event ingestion issues
+        - Analyzing customer usage patterns
+        - Building custom analytics dashboards
+        - Auditing billing-related events
+
+        ## Filtering Options:
+
+        - **Customer filtering**: Filter by specific customer ID
+        - **Event name filtering**: Filter by event type/name
+        - **Meter-based filtering**: Use a meter ID to apply the meter's event name and
+          filter criteria automatically
+        - **Time range filtering**: Filter events within a specific date range
+        - **Pagination**: Navigate through large result sets
+
+        ## Meter Integration:
+
+        When using `meter_id`, the endpoint automatically applies:
+
+        - The meter's configured `event_name` filter
+        - The meter's custom filter criteria (if any)
+        - If you also provide `event_name`, it must match the meter's event name
+
+        ## Example Queries:
+
+        - Get all events for a customer: `?customer_id=cus_abc123`
+        - Get API request events: `?event_name=api_request`
+        - Get events from last 24 hours:
+          `?start=2024-01-14T10:30:00Z&end=2024-01-15T10:30:00Z`
+        - Get events with meter filtering: `?meter_id=mtr_xyz789`
+        - Paginate results: `?page_size=50&page_number=2`
+
+        Args:
+          customer_id: Filter events by customer ID
+
+          end: Filter events created before this timestamp
+
+          event_name: Filter events by event name. If both event_name and meter_id are provided, they
+              must match the meter's configured event_name
+
+          meter_id: Filter events by meter ID. When provided, only events that match the meter's
+              event_name and filter criteria will be returned
+
+          page_number: Page number (0-based, default: 0)
+
+          page_size: Number of events to return per page (default: 10)
+
+          start: Filter events created after this timestamp
+
+          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_api_list(
+            "/events",
+            page=AsyncDefaultPageNumberPagination[Event],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "customer_id": customer_id,
+                        "end": end,
+                        "event_name": event_name,
+                        "meter_id": meter_id,
+                        "page_number": page_number,
+                        "page_size": page_size,
+                        "start": start,
+                    },
+                    usage_event_list_params.UsageEventListParams,
+                ),
+            ),
+            model=Event,
+        )
+
+    async def ingest(
+        self,
+        *,
+        events: Iterable[EventInputParam],
+        # 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,
+    ) -> UsageEventIngestResponse:
+        """
+        This endpoint allows you to ingest custom events that can be used for:
+
+        - Usage-based billing and metering
+        - Analytics and reporting
+        - Customer behavior tracking
+
+        ## Important Notes:
+
+        - **Duplicate Prevention**:
+          - Duplicate `event_id` values within the same request are rejected (entire
+            request fails)
+          - Subsequent requests with existing `event_id` values are ignored (idempotent
+            behavior)
+        - **Rate Limiting**: Maximum 1000 events per request
+        - **Time Validation**: Events with timestamps older than 1 hour or more than 5
+          minutes in the future will be rejected
+        - **Metadata Limits**: Maximum 50 key-value pairs per event, keys max 100 chars,
+          values max 500 chars
+
+        ## Example Usage:
+
+        ```json
+        {
+          "events": [
+            {
+              "event_id": "api_call_12345",
+              "customer_id": "cus_abc123",
+              "event_name": "api_request",
+              "timestamp": "2024-01-15T10:30:00Z",
+              "metadata": {
+                "endpoint": "/api/v1/users",
+                "method": "GET",
+                "tokens_used": "150"
+              }
+            }
+          ]
+        }
+        ```
+
+        Args:
+          events: List of events to be pushed
+
+          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(
+            "/events/ingest",
+            body=await async_maybe_transform({"events": events}, usage_event_ingest_params.UsageEventIngestParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=UsageEventIngestResponse,
+        )
+
+
+class UsageEventsResourceWithRawResponse:
+    def __init__(self, usage_events: UsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.retrieve = to_raw_response_wrapper(
+            usage_events.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            usage_events.list,
+        )
+        self.ingest = to_raw_response_wrapper(
+            usage_events.ingest,
+        )
+
+
+class AsyncUsageEventsResourceWithRawResponse:
+    def __init__(self, usage_events: AsyncUsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.retrieve = async_to_raw_response_wrapper(
+            usage_events.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            usage_events.list,
+        )
+        self.ingest = async_to_raw_response_wrapper(
+            usage_events.ingest,
+        )
+
+
+class UsageEventsResourceWithStreamingResponse:
+    def __init__(self, usage_events: UsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.retrieve = to_streamed_response_wrapper(
+            usage_events.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            usage_events.list,
+        )
+        self.ingest = to_streamed_response_wrapper(
+            usage_events.ingest,
+        )
+
+
+class AsyncUsageEventsResourceWithStreamingResponse:
+    def __init__(self, usage_events: AsyncUsageEventsResource) -> None:
+        self._usage_events = usage_events
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            usage_events.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            usage_events.list,
+        )
+        self.ingest = async_to_streamed_response_wrapper(
+            usage_events.ingest,
+        )

dodopayments/types/__init__.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 from .brand import Brand as Brand
+from .event import Event as Event
+from .meter import Meter as Meter
 from .price import Price as Price
 from .refund import Refund as Refund
 from .dispute import Dispute as Dispute
@@ -15,6 +17,7 @@ from .get_dispute import GetDispute as GetDispute
 from .license_key import LicenseKey as LicenseKey
 from .price_param import PriceParam as PriceParam
 from .country_code import CountryCode as CountryCode
+from .meter_filter import MeterFilter as MeterFilter
 from .subscription import Subscription as Subscription
 from .tax_category import TaxCategory as TaxCategory
 from .discount_type import DiscountType as DiscountType
@@ -27,8 +30,13 @@ from .dispute_status import DisputeStatus as DisputeStatus
 from .billing_address import BillingAddress as BillingAddress
 from .webhook_details import WebhookDetails as WebhookDetails
 from .addon_list_params import AddonListParams as AddonListParams
+from .event_input_param import EventInputParam as EventInputParam
+from .meter_aggregation import MeterAggregation as MeterAggregation
+from .meter_list_params import MeterListParams as MeterListParams
+from .add_meter_to_price import AddMeterToPrice as AddMeterToPrice
 from .attach_addon_param import AttachAddonParam as AttachAddonParam
 from .license_key_status import LicenseKeyStatus as LicenseKeyStatus
+from .meter_filter_param import MeterFilterParam as MeterFilterParam
 from .new_customer_param import NewCustomerParam as NewCustomerParam
 from .payout_list_params import PayoutListParams as PayoutListParams
 from .refund_list_params import RefundListParams as RefundListParams
@@ -39,6 +47,7 @@ from .brand_create_params import BrandCreateParams as BrandCreateParams
 from .brand_list_response import BrandListResponse as BrandListResponse
 from .brand_update_params import BrandUpdateParams as BrandUpdateParams
 from .dispute_list_params import DisputeListParams as DisputeListParams
+from .meter_create_params import MeterCreateParams as MeterCreateParams
 from .payment_list_params import PaymentListParams as PaymentListParams
 from .product_list_params import ProductListParams as ProductListParams
 from .subscription_status import SubscriptionStatus as SubscriptionStatus
@@ -68,7 +77,10 @@ from .customer_portal_session import CustomerPortalSession as CustomerPortalSess
 from .license_activate_params import LicenseActivateParams as LicenseActivateParams
 from .license_key_list_params import LicenseKeyListParams as LicenseKeyListParams
 from .license_validate_params import LicenseValidateParams as LicenseValidateParams
+from .meter_aggregation_param import MeterAggregationParam as MeterAggregationParam
 from .payment_create_response import PaymentCreateResponse as PaymentCreateResponse
+from .usage_event_list_params import UsageEventListParams as UsageEventListParams
+from .add_meter_to_price_param import AddMeterToPriceParam as AddMeterToPriceParam
 from .addon_cart_response_item import AddonCartResponseItem as AddonCartResponseItem
 from .customer_limited_details import CustomerLimitedDetails as CustomerLimitedDetails
 from .subscription_list_params import SubscriptionListParams as SubscriptionListParams
@@ -76,6 +88,7 @@ from .checkout_session_response import CheckoutSessionResponse as CheckoutSessio
 from .license_deactivate_params import LicenseDeactivateParams as LicenseDeactivateParams
 from .license_key_update_params import LicenseKeyUpdateParams as LicenseKeyUpdateParams
 from .license_validate_response import LicenseValidateResponse as LicenseValidateResponse
+from .usage_event_ingest_params import UsageEventIngestParams as UsageEventIngestParams
 from .license_key_duration_param import LicenseKeyDurationParam as LicenseKeyDurationParam
 from .one_time_product_cart_item import OneTimeProductCartItem as OneTimeProductCartItem
 from .subscription_charge_params import SubscriptionChargeParams as SubscriptionChargeParams
@@ -83,6 +96,7 @@ from .subscription_create_params import SubscriptionCreateParams as Subscription
 from .subscription_list_response import SubscriptionListResponse as SubscriptionListResponse
 from .subscription_update_params import SubscriptionUpdateParams as SubscriptionUpdateParams
 from .product_update_files_params import ProductUpdateFilesParams as ProductUpdateFilesParams
+from .usage_event_ingest_response import UsageEventIngestResponse as UsageEventIngestResponse
 from .addon_update_images_response import AddonUpdateImagesResponse as AddonUpdateImagesResponse
 from .brand_update_images_response import BrandUpdateImagesResponse as BrandUpdateImagesResponse
 from .on_demand_subscription_param import OnDemandSubscriptionParam as OnDemandSubscriptionParam
@@ -100,3 +114,9 @@ from .payment_retrieve_line_items_response import PaymentRetrieveLineItemsRespon
 from .misc_list_supported_countries_response import (
     MiscListSupportedCountriesResponse as MiscListSupportedCountriesResponse,
 )
+from .subscription_retrieve_usage_history_params import (
+    SubscriptionRetrieveUsageHistoryParams as SubscriptionRetrieveUsageHistoryParams,
+)
+from .subscription_retrieve_usage_history_response import (
+    SubscriptionRetrieveUsageHistoryResponse as SubscriptionRetrieveUsageHistoryResponse,
+)

dodopayments/types/add_meter_to_price.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["AddMeterToPrice"]
+
+
+class AddMeterToPrice(BaseModel):
+    meter_id: str
+
+    price_per_unit: str
+    """The price per unit in lowest denomination.
+
+    Must be greater than zero. Supports up to 5 digits before decimal point and 12
+    decimal places.
+    """
+
+    description: Optional[str] = None
+    """Meter description. Will ignored on Request, but will be shown in response"""
+
+    free_threshold: Optional[int] = None
+
+    measurement_unit: Optional[str] = None
+    """Meter measurement unit. Will ignored on Request, but will be shown in response"""
+
+    name: Optional[str] = None
+    """Meter name. Will ignored on Request, but will be shown in response"""