payi 0.1.0a33__py3-none-any.whl → 0.1.0a35__py3-none-any.whl

payi/resources/{budgets/budgets.py → limits/limits.py}

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import List, Union, Optional
+from datetime import datetime
 from typing_extensions import Literal
 
 import httpx
@@ -15,7 +16,7 @@ from .tags import (
     TagsResourceWithStreamingResponse,
     AsyncTagsResourceWithStreamingResponse,
 )
-from ...types import budget_list_params, budget_create_params, budget_update_params
+from ...types import limit_list_params, limit_reset_params, limit_create_params, limit_update_params
 from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from ..._utils import (
     maybe_transform,
@@ -30,49 +31,48 @@ from ..._response import (
     async_to_streamed_response_wrapper,
 )
 from ..._base_client import make_request_options
-from ...types.budget_response import BudgetResponse
+from ...types.limit_response import LimitResponse
 from ...types.default_response import DefaultResponse
-from ...types.paged_budget_list import PagedBudgetList
-from ...types.budget_history_response import BudgetHistoryResponse
+from ...types.paged_limit_list import PagedLimitList
+from ...types.limit_history_response import LimitHistoryResponse
 
-__all__ = ["BudgetsResource", "AsyncBudgetsResource"]
+__all__ = ["LimitsResource", "AsyncLimitsResource"]
 
 
-class BudgetsResource(SyncAPIResource):
+class LimitsResource(SyncAPIResource):
     @cached_property
     def tags(self) -> TagsResource:
         return TagsResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> BudgetsResourceWithRawResponse:
+    def with_raw_response(self) -> LimitsResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
         """
-        return BudgetsResourceWithRawResponse(self)
+        return LimitsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> BudgetsResourceWithStreamingResponse:
+    def with_streaming_response(self) -> LimitsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
         """
-        return BudgetsResourceWithStreamingResponse(self)
+        return LimitsResourceWithStreamingResponse(self)
 
     def create(
         self,
         *,
-        budget_name: str,
+        limit_name: str,
         max: float,
-        base_cost_estimate: Literal["max"] | NotGiven = NOT_GIVEN,
         billing_model_id: Optional[str] | NotGiven = NOT_GIVEN,
-        budget_response_type: Literal["block", "allow"] | NotGiven = NOT_GIVEN,
-        budget_tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
         cost_basis: Literal["base", "billed"] | NotGiven = NOT_GIVEN,
         currency: Literal["usd"] | NotGiven = NOT_GIVEN,
+        limit_tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        limit_type: Literal["block", "allow"] | NotGiven = NOT_GIVEN,
         threshold: Optional[float] | 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.
@@ -80,47 +80,43 @@ class BudgetsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> BudgetResponse:
+    ) -> LimitResponse:
         """
-        Create a Budget
+        Create a Limit
 
         Args:
-          budget_name (str): The name of the budget.
-          max (float): The maximum budget amount.
-          base_cost_estimate (Union[float, Literal['max']], optional): The base cost estimate. Defaults to 'max'.
-          budget_response_type (Literal['block', 'allow'], optional): The budget response type. Defaults to 'block'.
-          budget_tags (Union[List[str], None], optional): List of budget tags. Defaults to None.
-          budget_type (Literal['conservative', 'liberal'], optional): The budget type. Defaults to 'conservative'.
-          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
-          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
-          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
-          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
+          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(
-            "/api/v1/budgets",
+            "/api/v1/limits",
             body=maybe_transform(
                 {
-                    "budget_name": budget_name,
+                    "limit_name": limit_name,
                     "max": max,
-                    "base_cost_estimate": base_cost_estimate,
                     "billing_model_id": billing_model_id,
-                    "budget_response_type": budget_response_type,
-                    "budget_tags": budget_tags,
                     "cost_basis": cost_basis,
                     "currency": currency,
+                    "limit_tags": limit_tags,
+                    "limit_type": limit_type,
                     "threshold": threshold,
                 },
-                budget_create_params.BudgetCreateParams,
+                limit_create_params.LimitCreateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=BudgetResponse,
+            cast_to=LimitResponse,
         )
 
     def retrieve(
         self,
-        budget_id: str,
+        limit_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.
@@ -128,32 +124,34 @@ class BudgetsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> BudgetResponse:
+    ) -> LimitResponse:
         """
-        Get Budget details
+        Get Limit details
 
         Args:
-          budget_id (str): The ID of the budget.
-          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
-          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
-          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
-          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
-        """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+          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 limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return self._get(
-            f"/api/v1/budgets/{budget_id}",
+            f"/api/v1/limits/{limit_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=BudgetResponse,
+            cast_to=LimitResponse,
         )
 
     def update(
         self,
-        budget_id: str,
+        limit_id: str,
         *,
-        budget_name: Optional[str] | NotGiven = NOT_GIVEN,
+        limit_name: Optional[str] | NotGiven = NOT_GIVEN,
         max: Optional[float] | 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.
@@ -161,40 +159,40 @@ class BudgetsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> BudgetResponse:
+    ) -> LimitResponse:
         """
-        Update a Budget
+        Update a Limit
 
         Args:
-          budget_id (str): The ID of the budget.
-          budget_name (Union[str, optional]): The updated name of the budget. Defaults to None.
-          max (Union[float, optional])): The maximum budget amount. Defaults to None.
-          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
-          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
-          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
-          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
-        """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+          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 limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return self._put(
-            f"/api/v1/budgets/{budget_id}",
+            f"/api/v1/limits/{limit_id}",
             body=maybe_transform(
                 {
-                    "budget_name": budget_name,
+                    "limit_name": limit_name,
                     "max": max,
                 },
-                budget_update_params.BudgetUpdateParams,
+                limit_update_params.LimitUpdateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=BudgetResponse,
+            cast_to=LimitResponse,
         )
 
     def list(
         self,
         *,
-        budget_name: str | NotGiven = NOT_GIVEN,
+        limit_name: str | NotGiven = NOT_GIVEN,
         page_number: int | NotGiven = NOT_GIVEN,
         page_size: int | NotGiven = NOT_GIVEN,
         sort_ascending: bool | NotGiven = NOT_GIVEN,
@@ -206,18 +204,21 @@ class BudgetsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> PagedBudgetList:
+    ) -> PagedLimitList:
         """
-        Get all Budgets
+        Get all Limits
 
         Args:
-          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
-          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
-          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
-          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
+          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/v1/budgets",
+            "/api/v1/limits",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -225,22 +226,22 @@ class BudgetsResource(SyncAPIResource):
                 timeout=timeout,
                 query=maybe_transform(
                     {
-                        "budget_name": budget_name,
+                        "limit_name": limit_name,
                         "page_number": page_number,
                         "page_size": page_size,
                         "sort_ascending": sort_ascending,
                         "sort_by": sort_by,
                         "tags": tags,
                     },
-                    budget_list_params.BudgetListParams,
+                    limit_list_params.LimitListParams,
                 ),
             ),
-            cast_to=PagedBudgetList,
+            cast_to=PagedLimitList,
         )
 
     def delete(
         self,
-        budget_id: str,
+        limit_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.
@@ -250,19 +251,21 @@ class BudgetsResource(SyncAPIResource):
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> DefaultResponse:
         """
-        Delete a Budget
+        Delete a Limit
 
         Args:
-          budget_id (str): The ID of the budget.
-          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
-          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
-          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
-          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
-        """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+          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 limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return self._delete(
-            f"/api/v1/budgets/{budget_id}",
+            f"/api/v1/limits/{limit_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -271,71 +274,79 @@ class BudgetsResource(SyncAPIResource):
 
     def reset(
         self,
-        budget_id: str,
+        limit_id: str,
         *,
+        reset_date: 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,
-    ) -> BudgetHistoryResponse:
+    ) -> LimitHistoryResponse:
         """
-        Reset a Budget
+        Reset a Limit
 
         Args:
-          budget_id (str): The ID of the budget.
-          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
-          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
-          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
-          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
-        """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+          reset_date: Effective reset date
+
+          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 limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return self._post(
-            f"/api/v1/budgets/{budget_id}/reset",
+            f"/api/v1/limits/{limit_id}/reset",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"reset_date": reset_date}, limit_reset_params.LimitResetParams),
             ),
-            cast_to=BudgetHistoryResponse,
+            cast_to=LimitHistoryResponse,
         )
 
 
-class AsyncBudgetsResource(AsyncAPIResource):
+class AsyncLimitsResource(AsyncAPIResource):
     @cached_property
     def tags(self) -> AsyncTagsResource:
         return AsyncTagsResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> AsyncBudgetsResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncLimitsResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return the
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncBudgetsResourceWithRawResponse(self)
+        return AsyncLimitsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncBudgetsResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncLimitsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
         """
-        return AsyncBudgetsResourceWithStreamingResponse(self)
+        return AsyncLimitsResourceWithStreamingResponse(self)
 
     async def create(
         self,
         *,
-        budget_name: str,
+        limit_name: str,
         max: float,
-        base_cost_estimate: Literal["max"] | NotGiven = NOT_GIVEN,
         billing_model_id: Optional[str] | NotGiven = NOT_GIVEN,
-        budget_response_type: Literal["block", "allow"] | NotGiven = NOT_GIVEN,
-        budget_tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
         cost_basis: Literal["base", "billed"] | NotGiven = NOT_GIVEN,
         currency: Literal["usd"] | NotGiven = NOT_GIVEN,
+        limit_tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        limit_type: Literal["block", "allow"] | NotGiven = NOT_GIVEN,
         threshold: Optional[float] | 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.
@@ -343,9 +354,9 @@ class AsyncBudgetsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> BudgetResponse:
+    ) -> LimitResponse:
         """
-        Create a Budget
+        Create a Limit
 
         Args:
           extra_headers: Send extra headers
@@ -357,30 +368,29 @@ class AsyncBudgetsResource(AsyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return await self._post(
-            "/api/v1/budgets",
+            "/api/v1/limits",
             body=await async_maybe_transform(
                 {
-                    "budget_name": budget_name,
+                    "limit_name": limit_name,
                     "max": max,
-                    "base_cost_estimate": base_cost_estimate,
                     "billing_model_id": billing_model_id,
-                    "budget_response_type": budget_response_type,
-                    "budget_tags": budget_tags,
                     "cost_basis": cost_basis,
                     "currency": currency,
+                    "limit_tags": limit_tags,
+                    "limit_type": limit_type,
                     "threshold": threshold,
                 },
-                budget_create_params.BudgetCreateParams,
+                limit_create_params.LimitCreateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=BudgetResponse,
+            cast_to=LimitResponse,
         )
 
     async def retrieve(
         self,
-        budget_id: str,
+        limit_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.
@@ -388,9 +398,9 @@ class AsyncBudgetsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> BudgetResponse:
+    ) -> LimitResponse:
         """
-        Get Budget details
+        Get Limit details
 
         Args:
           extra_headers: Send extra headers
@@ -401,21 +411,21 @@ class AsyncBudgetsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+        if not limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return await self._get(
-            f"/api/v1/budgets/{budget_id}",
+            f"/api/v1/limits/{limit_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=BudgetResponse,
+            cast_to=LimitResponse,
         )
 
     async def update(
         self,
-        budget_id: str,
+        limit_id: str,
         *,
-        budget_name: Optional[str] | NotGiven = NOT_GIVEN,
+        limit_name: Optional[str] | NotGiven = NOT_GIVEN,
         max: Optional[float] | 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.
@@ -423,9 +433,9 @@ class AsyncBudgetsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> BudgetResponse:
+    ) -> LimitResponse:
         """
-        Update a Budget
+        Update a Limit
 
         Args:
           extra_headers: Send extra headers
@@ -436,27 +446,27 @@ class AsyncBudgetsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+        if not limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return await self._put(
-            f"/api/v1/budgets/{budget_id}",
+            f"/api/v1/limits/{limit_id}",
             body=await async_maybe_transform(
                 {
-                    "budget_name": budget_name,
+                    "limit_name": limit_name,
                     "max": max,
                 },
-                budget_update_params.BudgetUpdateParams,
+                limit_update_params.LimitUpdateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=BudgetResponse,
+            cast_to=LimitResponse,
         )
 
     async def list(
         self,
         *,
-        budget_name: str | NotGiven = NOT_GIVEN,
+        limit_name: str | NotGiven = NOT_GIVEN,
         page_number: int | NotGiven = NOT_GIVEN,
         page_size: int | NotGiven = NOT_GIVEN,
         sort_ascending: bool | NotGiven = NOT_GIVEN,
@@ -468,9 +478,9 @@ class AsyncBudgetsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> PagedBudgetList:
+    ) -> PagedLimitList:
         """
-        Get all Budgets
+        Get all Limits
 
         Args:
           extra_headers: Send extra headers
@@ -482,7 +492,7 @@ class AsyncBudgetsResource(AsyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return await self._get(
-            "/api/v1/budgets",
+            "/api/v1/limits",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -490,22 +500,22 @@ class AsyncBudgetsResource(AsyncAPIResource):
                 timeout=timeout,
                 query=await async_maybe_transform(
                     {
-                        "budget_name": budget_name,
+                        "limit_name": limit_name,
                         "page_number": page_number,
                         "page_size": page_size,
                         "sort_ascending": sort_ascending,
                         "sort_by": sort_by,
                         "tags": tags,
                     },
-                    budget_list_params.BudgetListParams,
+                    limit_list_params.LimitListParams,
                 ),
             ),
-            cast_to=PagedBudgetList,
+            cast_to=PagedLimitList,
         )
 
     async def delete(
         self,
-        budget_id: str,
+        limit_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.
@@ -515,7 +525,7 @@ class AsyncBudgetsResource(AsyncAPIResource):
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> DefaultResponse:
         """
-        Delete a Budget
+        Delete a Limit
 
         Args:
           extra_headers: Send extra headers
@@ -526,10 +536,10 @@ class AsyncBudgetsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+        if not limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return await self._delete(
-            f"/api/v1/budgets/{budget_id}",
+            f"/api/v1/limits/{limit_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -538,19 +548,22 @@ class AsyncBudgetsResource(AsyncAPIResource):
 
     async def reset(
         self,
-        budget_id: str,
+        limit_id: str,
         *,
+        reset_date: 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,
-    ) -> BudgetHistoryResponse:
+    ) -> LimitHistoryResponse:
         """
-        Reset a Budget
+        Reset a Limit
 
         Args:
+          reset_date: Effective reset date
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -559,124 +572,128 @@ class AsyncBudgetsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not budget_id:
-            raise ValueError(f"Expected a non-empty value for `budget_id` but received {budget_id!r}")
+        if not limit_id:
+            raise ValueError(f"Expected a non-empty value for `limit_id` but received {limit_id!r}")
         return await self._post(
-            f"/api/v1/budgets/{budget_id}/reset",
+            f"/api/v1/limits/{limit_id}/reset",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"reset_date": reset_date}, limit_reset_params.LimitResetParams),
             ),
-            cast_to=BudgetHistoryResponse,
+            cast_to=LimitHistoryResponse,
         )
 
 
-class BudgetsResourceWithRawResponse:
-    def __init__(self, budgets: BudgetsResource) -> None:
-        self._budgets = budgets
+class LimitsResourceWithRawResponse:
+    def __init__(self, limits: LimitsResource) -> None:
+        self._limits = limits
 
         self.create = to_raw_response_wrapper(
-            budgets.create,
+            limits.create,
         )
         self.retrieve = to_raw_response_wrapper(
-            budgets.retrieve,
+            limits.retrieve,
         )
         self.update = to_raw_response_wrapper(
-            budgets.update,
+            limits.update,
         )
         self.list = to_raw_response_wrapper(
-            budgets.list,
+            limits.list,
         )
         self.delete = to_raw_response_wrapper(
-            budgets.delete,
+            limits.delete,
         )
         self.reset = to_raw_response_wrapper(
-            budgets.reset,
+            limits.reset,
         )
 
     @cached_property
     def tags(self) -> TagsResourceWithRawResponse:
-        return TagsResourceWithRawResponse(self._budgets.tags)
+        return TagsResourceWithRawResponse(self._limits.tags)
 
 
-class AsyncBudgetsResourceWithRawResponse:
-    def __init__(self, budgets: AsyncBudgetsResource) -> None:
-        self._budgets = budgets
+class AsyncLimitsResourceWithRawResponse:
+    def __init__(self, limits: AsyncLimitsResource) -> None:
+        self._limits = limits
 
         self.create = async_to_raw_response_wrapper(
-            budgets.create,
+            limits.create,
         )
         self.retrieve = async_to_raw_response_wrapper(
-            budgets.retrieve,
+            limits.retrieve,
         )
         self.update = async_to_raw_response_wrapper(
-            budgets.update,
+            limits.update,
         )
         self.list = async_to_raw_response_wrapper(
-            budgets.list,
+            limits.list,
         )
         self.delete = async_to_raw_response_wrapper(
-            budgets.delete,
+            limits.delete,
         )
         self.reset = async_to_raw_response_wrapper(
-            budgets.reset,
+            limits.reset,
         )
 
     @cached_property
     def tags(self) -> AsyncTagsResourceWithRawResponse:
-        return AsyncTagsResourceWithRawResponse(self._budgets.tags)
+        return AsyncTagsResourceWithRawResponse(self._limits.tags)
 
 
-class BudgetsResourceWithStreamingResponse:
-    def __init__(self, budgets: BudgetsResource) -> None:
-        self._budgets = budgets
+class LimitsResourceWithStreamingResponse:
+    def __init__(self, limits: LimitsResource) -> None:
+        self._limits = limits
 
         self.create = to_streamed_response_wrapper(
-            budgets.create,
+            limits.create,
         )
         self.retrieve = to_streamed_response_wrapper(
-            budgets.retrieve,
+            limits.retrieve,
         )
         self.update = to_streamed_response_wrapper(
-            budgets.update,
+            limits.update,
         )
         self.list = to_streamed_response_wrapper(
-            budgets.list,
+            limits.list,
         )
         self.delete = to_streamed_response_wrapper(
-            budgets.delete,
+            limits.delete,
         )
         self.reset = to_streamed_response_wrapper(
-            budgets.reset,
+            limits.reset,
         )
 
     @cached_property
     def tags(self) -> TagsResourceWithStreamingResponse:
-        return TagsResourceWithStreamingResponse(self._budgets.tags)
+        return TagsResourceWithStreamingResponse(self._limits.tags)
 
 
-class AsyncBudgetsResourceWithStreamingResponse:
-    def __init__(self, budgets: AsyncBudgetsResource) -> None:
-        self._budgets = budgets
+class AsyncLimitsResourceWithStreamingResponse:
+    def __init__(self, limits: AsyncLimitsResource) -> None:
+        self._limits = limits
 
         self.create = async_to_streamed_response_wrapper(
-            budgets.create,
+            limits.create,
         )
         self.retrieve = async_to_streamed_response_wrapper(
-            budgets.retrieve,
+            limits.retrieve,
         )
         self.update = async_to_streamed_response_wrapper(
-            budgets.update,
+            limits.update,
         )
         self.list = async_to_streamed_response_wrapper(
-            budgets.list,
+            limits.list,
         )
         self.delete = async_to_streamed_response_wrapper(
-            budgets.delete,
+            limits.delete,
         )
         self.reset = async_to_streamed_response_wrapper(
-            budgets.reset,
+            limits.reset,
         )
 
     @cached_property
     def tags(self) -> AsyncTagsResourceWithStreamingResponse:
-        return AsyncTagsResourceWithStreamingResponse(self._budgets.tags)
+        return AsyncTagsResourceWithStreamingResponse(self._limits.tags)