payi 0.1.0a37__py3-none-any.whl → 0.1.0a39__py3-none-any.whl

payi/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "payi"
-__version__ = "0.1.0-alpha.37"  # x-release-please-version
+__version__ = "0.1.0-alpha.39"  # x-release-please-version

payi/resources/experiences/experiences.py

@@ -4,14 +4,6 @@ from __future__ import annotations
 
 import httpx
 
-from .types import (
-    TypesResource,
-    AsyncTypesResource,
-    TypesResourceWithRawResponse,
-    AsyncTypesResourceWithRawResponse,
-    TypesResourceWithStreamingResponse,
-    AsyncTypesResourceWithStreamingResponse,
-)
 from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from ..._compat import cached_property
 from .properties import (
@@ -29,6 +21,14 @@ from ..._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
+from .types.types import (
+    TypesResource,
+    AsyncTypesResource,
+    TypesResourceWithRawResponse,
+    AsyncTypesResourceWithRawResponse,
+    TypesResourceWithStreamingResponse,
+    AsyncTypesResourceWithStreamingResponse,
+)
 from ..._base_client import make_request_options
 from ...types.experience_instance_response import ExperienceInstanceResponse
 

payi/resources/experiences/types/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .types import (
+    TypesResource,
+    AsyncTypesResource,
+    TypesResourceWithRawResponse,
+    AsyncTypesResourceWithRawResponse,
+    TypesResourceWithStreamingResponse,
+    AsyncTypesResourceWithStreamingResponse,
+)
+from .limit_config import (
+    LimitConfigResource,
+    AsyncLimitConfigResource,
+    LimitConfigResourceWithRawResponse,
+    AsyncLimitConfigResourceWithRawResponse,
+    LimitConfigResourceWithStreamingResponse,
+    AsyncLimitConfigResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "LimitConfigResource",
+    "AsyncLimitConfigResource",
+    "LimitConfigResourceWithRawResponse",
+    "AsyncLimitConfigResourceWithRawResponse",
+    "LimitConfigResourceWithStreamingResponse",
+    "AsyncLimitConfigResourceWithStreamingResponse",
+    "TypesResource",
+    "AsyncTypesResource",
+    "TypesResourceWithRawResponse",
+    "AsyncTypesResourceWithRawResponse",
+    "TypesResourceWithStreamingResponse",
+    "AsyncTypesResourceWithStreamingResponse",
+]

payi/resources/experiences/types/limit_config.py

@@ -0,0 +1,275 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+import httpx
+
+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 ...._base_client import make_request_options
+from ....types.experiences.types import limit_config_create_params
+from ....types.experiences.experience_type import ExperienceType
+
+__all__ = ["LimitConfigResource", "AsyncLimitConfigResource"]
+
+
+class LimitConfigResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> LimitConfigResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return LimitConfigResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> LimitConfigResourceWithStreamingResponse:
+        """
+        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 LimitConfigResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        experience_name: str,
+        *,
+        max: float,
+        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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExperienceType:
+        """
+        Create a new Experience Type default limit configuration
+
+        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 experience_name:
+            raise ValueError(f"Expected a non-empty value for `experience_name` but received {experience_name!r}")
+        return self._post(
+            f"/api/v1/experiences/types/{experience_name}/limit_config",
+            body=maybe_transform(
+                {
+                    "max": max,
+                    "limit_tags": limit_tags,
+                    "limit_type": limit_type,
+                    "threshold": threshold,
+                },
+                limit_config_create_params.LimitConfigCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExperienceType,
+        )
+
+    def delete(
+        self,
+        experience_name: 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,
+    ) -> ExperienceType:
+        """
+        Delete an Experience Type default limit configuration
+
+        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 experience_name:
+            raise ValueError(f"Expected a non-empty value for `experience_name` but received {experience_name!r}")
+        return self._delete(
+            f"/api/v1/experiences/types/{experience_name}/limit_config",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExperienceType,
+        )
+
+
+class AsyncLimitConfigResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncLimitConfigResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncLimitConfigResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncLimitConfigResourceWithStreamingResponse:
+        """
+        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 AsyncLimitConfigResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        experience_name: str,
+        *,
+        max: float,
+        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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExperienceType:
+        """
+        Create a new Experience Type default limit configuration
+
+        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 experience_name:
+            raise ValueError(f"Expected a non-empty value for `experience_name` but received {experience_name!r}")
+        return await self._post(
+            f"/api/v1/experiences/types/{experience_name}/limit_config",
+            body=await async_maybe_transform(
+                {
+                    "max": max,
+                    "limit_tags": limit_tags,
+                    "limit_type": limit_type,
+                    "threshold": threshold,
+                },
+                limit_config_create_params.LimitConfigCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExperienceType,
+        )
+
+    async def delete(
+        self,
+        experience_name: 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,
+    ) -> ExperienceType:
+        """
+        Delete an Experience Type default limit configuration
+
+        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 experience_name:
+            raise ValueError(f"Expected a non-empty value for `experience_name` but received {experience_name!r}")
+        return await self._delete(
+            f"/api/v1/experiences/types/{experience_name}/limit_config",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExperienceType,
+        )
+
+
+class LimitConfigResourceWithRawResponse:
+    def __init__(self, limit_config: LimitConfigResource) -> None:
+        self._limit_config = limit_config
+
+        self.create = to_raw_response_wrapper(
+            limit_config.create,
+        )
+        self.delete = to_raw_response_wrapper(
+            limit_config.delete,
+        )
+
+
+class AsyncLimitConfigResourceWithRawResponse:
+    def __init__(self, limit_config: AsyncLimitConfigResource) -> None:
+        self._limit_config = limit_config
+
+        self.create = async_to_raw_response_wrapper(
+            limit_config.create,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            limit_config.delete,
+        )
+
+
+class LimitConfigResourceWithStreamingResponse:
+    def __init__(self, limit_config: LimitConfigResource) -> None:
+        self._limit_config = limit_config
+
+        self.create = to_streamed_response_wrapper(
+            limit_config.create,
+        )
+        self.delete = to_streamed_response_wrapper(
+            limit_config.delete,
+        )
+
+
+class AsyncLimitConfigResourceWithStreamingResponse:
+    def __init__(self, limit_config: AsyncLimitConfigResource) -> None:
+        self._limit_config = limit_config
+
+        self.create = async_to_streamed_response_wrapper(
+            limit_config.create,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            limit_config.delete,
+        )

payi/resources/experiences/{types.py → types/types.py}

@@ -6,28 +6,40 @@ from typing import Optional
 
 import httpx
 
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._utils import (
+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 (
+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.experiences import type_list_params, type_create_params, type_update_params
-from ...types.experiences.experience_type import ExperienceType
-from ...types.experiences.type_list_response import TypeListResponse
+from .limit_config import (
+    LimitConfigResource,
+    AsyncLimitConfigResource,
+    LimitConfigResourceWithRawResponse,
+    AsyncLimitConfigResourceWithRawResponse,
+    LimitConfigResourceWithStreamingResponse,
+    AsyncLimitConfigResourceWithStreamingResponse,
+)
+from ...._base_client import make_request_options
+from ....types.experiences import type_list_params, type_create_params, type_update_params
+from ....types.experiences.experience_type import ExperienceType
+from ....types.experiences.type_list_response import TypeListResponse
 
 __all__ = ["TypesResource", "AsyncTypesResource"]
 
 
 class TypesResource(SyncAPIResource):
+    @cached_property
+    def limit_config(self) -> LimitConfigResource:
+        return LimitConfigResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> TypesResourceWithRawResponse:
         """
@@ -52,6 +64,7 @@ class TypesResource(SyncAPIResource):
         *,
         description: str,
         name: str,
+        limit_config: type_create_params.LimitConfig | NotGiven = NOT_GIVEN,
         logging_enabled: Optional[bool] | 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.
@@ -78,6 +91,7 @@ class TypesResource(SyncAPIResource):
                 {
                     "description": description,
                     "name": name,
+                    "limit_config": limit_config,
                     "logging_enabled": logging_enabled,
                 },
                 type_create_params.TypeCreateParams,
@@ -125,7 +139,7 @@ class TypesResource(SyncAPIResource):
         self,
         experience_name: str,
         *,
-        description: Optional[str],
+        description: Optional[str] | NotGiven = NOT_GIVEN,
         logging_enabled: Optional[bool] | 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.
@@ -235,6 +249,10 @@ class TypesResource(SyncAPIResource):
 
 
 class AsyncTypesResource(AsyncAPIResource):
+    @cached_property
+    def limit_config(self) -> AsyncLimitConfigResource:
+        return AsyncLimitConfigResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncTypesResourceWithRawResponse:
         """
@@ -259,6 +277,7 @@ class AsyncTypesResource(AsyncAPIResource):
         *,
         description: str,
         name: str,
+        limit_config: type_create_params.LimitConfig | NotGiven = NOT_GIVEN,
         logging_enabled: Optional[bool] | 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.
@@ -285,6 +304,7 @@ class AsyncTypesResource(AsyncAPIResource):
                 {
                     "description": description,
                     "name": name,
+                    "limit_config": limit_config,
                     "logging_enabled": logging_enabled,
                 },
                 type_create_params.TypeCreateParams,
@@ -332,7 +352,7 @@ class AsyncTypesResource(AsyncAPIResource):
         self,
         experience_name: str,
         *,
-        description: Optional[str],
+        description: Optional[str] | NotGiven = NOT_GIVEN,
         logging_enabled: Optional[bool] | 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.
@@ -461,6 +481,10 @@ class TypesResourceWithRawResponse:
             types.delete,
         )
 
+    @cached_property
+    def limit_config(self) -> LimitConfigResourceWithRawResponse:
+        return LimitConfigResourceWithRawResponse(self._types.limit_config)
+
 
 class AsyncTypesResourceWithRawResponse:
     def __init__(self, types: AsyncTypesResource) -> None:
@@ -482,6 +506,10 @@ class AsyncTypesResourceWithRawResponse:
             types.delete,
         )
 
+    @cached_property
+    def limit_config(self) -> AsyncLimitConfigResourceWithRawResponse:
+        return AsyncLimitConfigResourceWithRawResponse(self._types.limit_config)
+
 
 class TypesResourceWithStreamingResponse:
     def __init__(self, types: TypesResource) -> None:
@@ -503,6 +531,10 @@ class TypesResourceWithStreamingResponse:
             types.delete,
         )
 
+    @cached_property
+    def limit_config(self) -> LimitConfigResourceWithStreamingResponse:
+        return LimitConfigResourceWithStreamingResponse(self._types.limit_config)
+
 
 class AsyncTypesResourceWithStreamingResponse:
     def __init__(self, types: AsyncTypesResource) -> None:
@@ -523,3 +555,7 @@ class AsyncTypesResourceWithStreamingResponse:
         self.delete = async_to_streamed_response_wrapper(
             types.delete,
         )
+
+    @cached_property
+    def limit_config(self) -> AsyncLimitConfigResourceWithStreamingResponse:
+        return AsyncLimitConfigResourceWithStreamingResponse(self._types.limit_config)

payi/resources/ingest.py

@@ -24,8 +24,6 @@ from .._response import (
 )
 from .._base_client import make_request_options
 from ..types.ingest_response import IngestResponse
-from ..types.ingest_event_param import IngestEventParam
-from ..types.bulk_ingest_response import BulkIngestResponse
 from ..types.pay_i_common_models_api_router_header_info_param import PayICommonModelsAPIRouterHeaderInfoParam
 
 __all__ = ["IngestResource", "AsyncIngestResource"]
@@ -51,41 +49,6 @@ class IngestResource(SyncAPIResource):
         """
         return IngestResourceWithStreamingResponse(self)
 
-    def bulk(
-        self,
-        *,
-        events: Iterable[IngestEventParam],
-        # 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,
-    ) -> BulkIngestResponse:
-        """
-        Bulk Ingest
-
-        Args:
-
-          items (Iterable[IngestUnitsParams]): The items to ingest
-
-          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/ingest/bulk",
-            body=maybe_transform(events, Iterable[IngestEventParam]),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=BulkIngestResponse,
-        )
-
     def units(
         self,
         *,
@@ -237,40 +200,6 @@ class AsyncIngestResource(AsyncAPIResource):
         """
         return AsyncIngestResourceWithStreamingResponse(self)
 
-    async def bulk(
-        self,
-        *,
-        events: Iterable[IngestEventParam],
-        # 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,
-    ) -> BulkIngestResponse:
-        """
-        Bulk Ingest
-
-        Args:
-          items (Iterable[IngestUnitsParams]): The items to ingest
-
-          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(
-            "/api/v1/ingest/bulk",
-            body=await async_maybe_transform(events, Iterable[IngestEventParam]),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=BulkIngestResponse,
-        )
-
     async def units(
         self,
         *,
@@ -405,9 +334,6 @@ class IngestResourceWithRawResponse:
     def __init__(self, ingest: IngestResource) -> None:
         self._ingest = ingest
 
-        self.bulk = to_raw_response_wrapper(
-            ingest.bulk,
-        )
         self.units = to_raw_response_wrapper(
             ingest.units,
         )
@@ -417,9 +343,6 @@ class AsyncIngestResourceWithRawResponse:
     def __init__(self, ingest: AsyncIngestResource) -> None:
         self._ingest = ingest
 
-        self.bulk = async_to_raw_response_wrapper(
-            ingest.bulk,
-        )
         self.units = async_to_raw_response_wrapper(
             ingest.units,
         )
@@ -429,9 +352,6 @@ class IngestResourceWithStreamingResponse:
     def __init__(self, ingest: IngestResource) -> None:
         self._ingest = ingest
 
-        self.bulk = to_streamed_response_wrapper(
-            ingest.bulk,
-        )
         self.units = to_streamed_response_wrapper(
             ingest.units,
         )
@@ -441,9 +361,6 @@ class AsyncIngestResourceWithStreamingResponse:
     def __init__(self, ingest: AsyncIngestResource) -> None:
         self._ingest = ingest
 
-        self.bulk = async_to_streamed_response_wrapper(
-            ingest.bulk,
-        )
         self.units = async_to_streamed_response_wrapper(
             ingest.units,
         )

payi/resources/limits/limits.py

@@ -69,8 +69,7 @@ class LimitsResource(SyncAPIResource):
         limit_name: str,
         max: float,
         billing_model_id: Optional[str] | NotGiven = NOT_GIVEN,
-        cost_basis: Literal["base", "billed"] | NotGiven = NOT_GIVEN,
-        currency: Literal["usd"] | NotGiven = NOT_GIVEN,
+        limit_basis: Literal["base", "billed"] | 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,
@@ -100,8 +99,7 @@ class LimitsResource(SyncAPIResource):
                     "limit_name": limit_name,
                     "max": max,
                     "billing_model_id": billing_model_id,
-                    "cost_basis": cost_basis,
-                    "currency": currency,
+                    "limit_basis": limit_basis,
                     "limit_tags": limit_tags,
                     "limit_type": limit_type,
                     "threshold": threshold,
@@ -343,8 +341,7 @@ class AsyncLimitsResource(AsyncAPIResource):
         limit_name: str,
         max: float,
         billing_model_id: Optional[str] | NotGiven = NOT_GIVEN,
-        cost_basis: Literal["base", "billed"] | NotGiven = NOT_GIVEN,
-        currency: Literal["usd"] | NotGiven = NOT_GIVEN,
+        limit_basis: Literal["base", "billed"] | 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,
@@ -374,8 +371,7 @@ class AsyncLimitsResource(AsyncAPIResource):
                     "limit_name": limit_name,
                     "max": max,
                     "billing_model_id": billing_model_id,
-                    "cost_basis": cost_basis,
-                    "currency": currency,
+                    "limit_basis": limit_basis,
                     "limit_tags": limit_tags,
                     "limit_type": limit_type,
                     "threshold": threshold,

payi/resources/requests/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .result import (
+    ResultResource,
+    AsyncResultResource,
+    ResultResourceWithRawResponse,
+    AsyncResultResourceWithRawResponse,
+    ResultResourceWithStreamingResponse,
+    AsyncResultResourceWithStreamingResponse,
+)
 from .requests import (
     RequestsResource,
     AsyncRequestsResource,
@@ -24,6 +32,12 @@ __all__ = [
     "AsyncPropertiesResourceWithRawResponse",
     "PropertiesResourceWithStreamingResponse",
     "AsyncPropertiesResourceWithStreamingResponse",
+    "ResultResource",
+    "AsyncResultResource",
+    "ResultResourceWithRawResponse",
+    "AsyncResultResourceWithRawResponse",
+    "ResultResourceWithStreamingResponse",
+    "AsyncResultResourceWithStreamingResponse",
     "RequestsResource",
     "AsyncRequestsResource",
     "RequestsResourceWithRawResponse",