feat(api): OpenAPI spec update via Stainless API (#443)

.stats.yml

@@ -1,2 +1,2 @@
-configured_endpoints: 1267
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-6229bf7c4bed6b9026088be8817d3c8111576b2d12ff5220d193f479f230e449.yml
+configured_endpoints: 1268
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-7a581c61bc42c6e3e48c58c941255dca8f4b7b2e5aafd402a61c6438c2830071.yml

api.md

@@ -3631,9 +3631,13 @@ Methods:
 Types:
 
 ```python
-from cloudflare.types.intel import Whois
+from cloudflare.types.intel import Whois, WhoisGetResponse
 ```
 
+Methods:
+
+- <code title="get /accounts/{account_id}/intel/whois">client.intel.whois.<a href="./src/cloudflare/resources/intel/whois.py">get</a>(\*, account_id, \*\*<a href="src/cloudflare/types/intel/whois_get_params.py">params</a>) -> <a href="./src/cloudflare/types/intel/whois_get_response.py">WhoisGetResponse</a></code>
+
 ## IndicatorFeeds
 
 Types:

src/cloudflare/resources/intel/__init__.py

@@ -32,6 +32,14 @@
     IntelResourceWithStreamingResponse,
     AsyncIntelResourceWithStreamingResponse,
 )
+from .whois import (
+    WhoisResource,
+    AsyncWhoisResource,
+    WhoisResourceWithRawResponse,
+    AsyncWhoisResourceWithRawResponse,
+    WhoisResourceWithStreamingResponse,
+    AsyncWhoisResourceWithStreamingResponse,
+)
 from .domains import (
     DomainsResource,
     AsyncDomainsResource,
@@ -132,6 +140,12 @@
     "AsyncMiscategorizationsResourceWithRawResponse",
     "MiscategorizationsResourceWithStreamingResponse",
     "AsyncMiscategorizationsResourceWithStreamingResponse",
+    "WhoisResource",
+    "AsyncWhoisResource",
+    "WhoisResourceWithRawResponse",
+    "AsyncWhoisResourceWithRawResponse",
+    "WhoisResourceWithStreamingResponse",
+    "AsyncWhoisResourceWithStreamingResponse",
     "IndicatorFeedsResource",
     "AsyncIndicatorFeedsResource",
     "IndicatorFeedsResourceWithRawResponse",

src/cloudflare/resources/intel/intel.py

@@ -26,6 +26,14 @@
     IPsResourceWithStreamingResponse,
     AsyncIPsResourceWithStreamingResponse,
 )
+from .whois import (
+    WhoisResource,
+    AsyncWhoisResource,
+    WhoisResourceWithRawResponse,
+    AsyncWhoisResourceWithRawResponse,
+    WhoisResourceWithStreamingResponse,
+    AsyncWhoisResourceWithStreamingResponse,
+)
 from .asn.asn import ASNResource, AsyncASNResource
 from .domains import (
     DomainsResource,
@@ -121,6 +129,10 @@ def ip_lists(self) -> IPListsResource:
     def miscategorizations(self) -> MiscategorizationsResource:
         return MiscategorizationsResource(self._client)
 
+    @cached_property
+    def whois(self) -> WhoisResource:
+        return WhoisResource(self._client)
+
     @cached_property
     def indicator_feeds(self) -> IndicatorFeedsResource:
         return IndicatorFeedsResource(self._client)
@@ -171,6 +183,10 @@ def ip_lists(self) -> AsyncIPListsResource:
     def miscategorizations(self) -> AsyncMiscategorizationsResource:
         return AsyncMiscategorizationsResource(self._client)
 
+    @cached_property
+    def whois(self) -> AsyncWhoisResource:
+        return AsyncWhoisResource(self._client)
+
     @cached_property
     def indicator_feeds(self) -> AsyncIndicatorFeedsResource:
         return AsyncIndicatorFeedsResource(self._client)
@@ -224,6 +240,10 @@ def ip_lists(self) -> IPListsResourceWithRawResponse:
     def miscategorizations(self) -> MiscategorizationsResourceWithRawResponse:
         return MiscategorizationsResourceWithRawResponse(self._intel.miscategorizations)
 
+    @cached_property
+    def whois(self) -> WhoisResourceWithRawResponse:
+        return WhoisResourceWithRawResponse(self._intel.whois)
+
     @cached_property
     def indicator_feeds(self) -> IndicatorFeedsResourceWithRawResponse:
         return IndicatorFeedsResourceWithRawResponse(self._intel.indicator_feeds)
@@ -269,6 +289,10 @@ def ip_lists(self) -> AsyncIPListsResourceWithRawResponse:
     def miscategorizations(self) -> AsyncMiscategorizationsResourceWithRawResponse:
         return AsyncMiscategorizationsResourceWithRawResponse(self._intel.miscategorizations)
 
+    @cached_property
+    def whois(self) -> AsyncWhoisResourceWithRawResponse:
+        return AsyncWhoisResourceWithRawResponse(self._intel.whois)
+
     @cached_property
     def indicator_feeds(self) -> AsyncIndicatorFeedsResourceWithRawResponse:
         return AsyncIndicatorFeedsResourceWithRawResponse(self._intel.indicator_feeds)
@@ -314,6 +338,10 @@ def ip_lists(self) -> IPListsResourceWithStreamingResponse:
     def miscategorizations(self) -> MiscategorizationsResourceWithStreamingResponse:
         return MiscategorizationsResourceWithStreamingResponse(self._intel.miscategorizations)
 
+    @cached_property
+    def whois(self) -> WhoisResourceWithStreamingResponse:
+        return WhoisResourceWithStreamingResponse(self._intel.whois)
+
     @cached_property
     def indicator_feeds(self) -> IndicatorFeedsResourceWithStreamingResponse:
         return IndicatorFeedsResourceWithStreamingResponse(self._intel.indicator_feeds)
@@ -359,6 +387,10 @@ def ip_lists(self) -> AsyncIPListsResourceWithStreamingResponse:
     def miscategorizations(self) -> AsyncMiscategorizationsResourceWithStreamingResponse:
         return AsyncMiscategorizationsResourceWithStreamingResponse(self._intel.miscategorizations)
 
+    @cached_property
+    def whois(self) -> AsyncWhoisResourceWithStreamingResponse:
+        return AsyncWhoisResourceWithStreamingResponse(self._intel.whois)
+
     @cached_property
     def indicator_feeds(self) -> AsyncIndicatorFeedsResourceWithStreamingResponse:
         return AsyncIndicatorFeedsResourceWithStreamingResponse(self._intel.indicator_feeds)

src/cloudflare/resources/intel/whois.py

@@ -0,0 +1,167 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Type, cast
+
+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 ..._wrappers import ResultWrapper
+from ...types.intel import whois_get_params
+from ..._base_client import (
+    make_request_options,
+)
+from ...types.intel.whois_get_response import WhoisGetResponse
+
+__all__ = ["WhoisResource", "AsyncWhoisResource"]
+
+
+class WhoisResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> WhoisResourceWithRawResponse:
+        return WhoisResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> WhoisResourceWithStreamingResponse:
+        return WhoisResourceWithStreamingResponse(self)
+
+    def get(
+        self,
+        *,
+        account_id: str,
+        domain: str | 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,
+    ) -> WhoisGetResponse:
+        """
+        Get WHOIS Record
+
+        Args:
+          account_id: Identifier
+
+          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 account_id:
+            raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}")
+        return self._get(
+            f"/accounts/{account_id}/intel/whois",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"domain": domain}, whois_get_params.WhoisGetParams),
+                post_parser=ResultWrapper[WhoisGetResponse]._unwrapper,
+            ),
+            cast_to=cast(Type[WhoisGetResponse], ResultWrapper[WhoisGetResponse]),
+        )
+
+
+class AsyncWhoisResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncWhoisResourceWithRawResponse:
+        return AsyncWhoisResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncWhoisResourceWithStreamingResponse:
+        return AsyncWhoisResourceWithStreamingResponse(self)
+
+    async def get(
+        self,
+        *,
+        account_id: str,
+        domain: str | 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,
+    ) -> WhoisGetResponse:
+        """
+        Get WHOIS Record
+
+        Args:
+          account_id: Identifier
+
+          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 account_id:
+            raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}")
+        return await self._get(
+            f"/accounts/{account_id}/intel/whois",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"domain": domain}, whois_get_params.WhoisGetParams),
+                post_parser=ResultWrapper[WhoisGetResponse]._unwrapper,
+            ),
+            cast_to=cast(Type[WhoisGetResponse], ResultWrapper[WhoisGetResponse]),
+        )
+
+
+class WhoisResourceWithRawResponse:
+    def __init__(self, whois: WhoisResource) -> None:
+        self._whois = whois
+
+        self.get = to_raw_response_wrapper(
+            whois.get,
+        )
+
+
+class AsyncWhoisResourceWithRawResponse:
+    def __init__(self, whois: AsyncWhoisResource) -> None:
+        self._whois = whois
+
+        self.get = async_to_raw_response_wrapper(
+            whois.get,
+        )
+
+
+class WhoisResourceWithStreamingResponse:
+    def __init__(self, whois: WhoisResource) -> None:
+        self._whois = whois
+
+        self.get = to_streamed_response_wrapper(
+            whois.get,
+        )
+
+
+class AsyncWhoisResourceWithStreamingResponse:
+    def __init__(self, whois: AsyncWhoisResource) -> None:
+        self._whois = whois
+
+        self.get = async_to_streamed_response_wrapper(
+            whois.get,
+        )

src/cloudflare/types/intel/__init__.py

@@ -11,8 +11,10 @@
 from .domain_history import DomainHistory as DomainHistory
 from .dns_list_params import DNSListParams as DNSListParams
 from .ip_get_response import IPGetResponse as IPGetResponse
+from .whois_get_params import WhoisGetParams as WhoisGetParams
 from .dns_list_response import DNSListResponse as DNSListResponse
 from .domain_get_params import DomainGetParams as DomainGetParams
+from .whois_get_response import WhoisGetResponse as WhoisGetResponse
 from .ip_list_get_response import IPListGetResponse as IPListGetResponse
 from .domain_history_get_params import DomainHistoryGetParams as DomainHistoryGetParams
 from .domain_history_get_response import DomainHistoryGetResponse as DomainHistoryGetResponse

src/cloudflare/types/intel/whois_get_params.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["WhoisGetParams"]
+
+
+class WhoisGetParams(TypedDict, total=False):
+    account_id: Required[str]
+    """Identifier"""
+
+    domain: str