diff --git a/.stats.yml b/.stats.yml index 4ca19da8d57..7c77f4e67bf 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 1548 +configured_endpoints: 1570 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-cc9be7885f16989f56e5e015644178eb17b82304fc31f62ed14b7e9a93cab891.yml diff --git a/api.md b/api.md index 8f43fddb224..363c6d88287 100644 --- a/api.md +++ b/api.md @@ -6970,6 +6970,16 @@ Methods: ## DNS +Types: + +```python +from cloudflare.types.radar import DNSTimeseriesResponse +``` + +Methods: + +- client.radar.dns.timeseries(\*\*params) -> DNSTimeseriesResponse + ### Top Types: @@ -6983,6 +6993,70 @@ Methods: - client.radar.dns.top.ases(\*\*params) -> TopAsesResponse - client.radar.dns.top.locations(\*\*params) -> TopLocationsResponse +### Summary + +Types: + +```python +from cloudflare.types.radar.dns import ( + SummaryCacheHitResponse, + SummaryDNSSECResponse, + SummaryDNSSECAwareResponse, + SummaryDNSSECE2EResponse, + SummaryIPVersionResponse, + SummaryMatchingAnswerResponse, + SummaryProtocolResponse, + SummaryQueryTypeResponse, + SummaryResponseCodeResponse, + SummaryResponseTTLResponse, +) +``` + +Methods: + +- client.radar.dns.summary.cache_hit(\*\*params) -> SummaryCacheHitResponse +- client.radar.dns.summary.dnssec(\*\*params) -> SummaryDNSSECResponse +- client.radar.dns.summary.dnssec_aware(\*\*params) -> SummaryDNSSECAwareResponse +- client.radar.dns.summary.dnssec_e2e(\*\*params) -> SummaryDNSSECE2EResponse +- client.radar.dns.summary.ip_version(\*\*params) -> SummaryIPVersionResponse +- client.radar.dns.summary.matching_answer(\*\*params) -> SummaryMatchingAnswerResponse +- client.radar.dns.summary.protocol(\*\*params) -> SummaryProtocolResponse +- client.radar.dns.summary.query_type(\*\*params) -> SummaryQueryTypeResponse +- client.radar.dns.summary.response_code(\*\*params) -> SummaryResponseCodeResponse +- client.radar.dns.summary.response_ttl(\*\*params) -> SummaryResponseTTLResponse + +### TimeseriesGroups + +Types: + +```python +from cloudflare.types.radar.dns import ( + TimeseriesGroupCacheHitResponse, + TimeseriesGroupDNSSECResponse, + TimeseriesGroupDNSSECAwareResponse, + TimeseriesGroupDNSSECE2EResponse, + TimeseriesGroupIPVersionResponse, + TimeseriesGroupMatchingAnswerResponse, + TimeseriesGroupProtocolResponse, + TimeseriesGroupQueryTypeResponse, + TimeseriesGroupResponseCodeResponse, + TimeseriesGroupResponseTTLResponse, +) +``` + +Methods: + +- client.radar.dns.timeseries_groups.cache_hit(\*\*params) -> TimeseriesGroupCacheHitResponse +- client.radar.dns.timeseries_groups.dnssec(\*\*params) -> TimeseriesGroupDNSSECResponse +- client.radar.dns.timeseries_groups.dnssec_aware(\*\*params) -> TimeseriesGroupDNSSECAwareResponse +- client.radar.dns.timeseries_groups.dnssec_e2e(\*\*params) -> TimeseriesGroupDNSSECE2EResponse +- client.radar.dns.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse +- client.radar.dns.timeseries_groups.matching_answer(\*\*params) -> TimeseriesGroupMatchingAnswerResponse +- client.radar.dns.timeseries_groups.protocol(\*\*params) -> TimeseriesGroupProtocolResponse +- client.radar.dns.timeseries_groups.query_type(\*\*params) -> TimeseriesGroupQueryTypeResponse +- client.radar.dns.timeseries_groups.response_code(\*\*params) -> TimeseriesGroupResponseCodeResponse +- client.radar.dns.timeseries_groups.response_ttl(\*\*params) -> TimeseriesGroupResponseTTLResponse + ## Netflows Types: @@ -7900,6 +7974,7 @@ Types: ```python from cloudflare.types.radar.ranking import ( + InternetServiceCategoriesResponse, InternetServiceTimeseriesGroupsResponse, InternetServiceTopResponse, ) @@ -7907,6 +7982,7 @@ from cloudflare.types.radar.ranking import ( Methods: +- client.radar.ranking.internet_services.categories(\*\*params) -> InternetServiceCategoriesResponse - client.radar.ranking.internet_services.timeseries_groups(\*\*params) -> InternetServiceTimeseriesGroupsResponse - client.radar.ranking.internet_services.top(\*\*params) -> InternetServiceTopResponse diff --git a/src/cloudflare/resources/radar/dns/__init__.py b/src/cloudflare/resources/radar/dns/__init__.py index c6dbec78760..71c475bb3c8 100644 --- a/src/cloudflare/resources/radar/dns/__init__.py +++ b/src/cloudflare/resources/radar/dns/__init__.py @@ -16,6 +16,22 @@ TopResourceWithStreamingResponse, AsyncTopResourceWithStreamingResponse, ) +from .summary import ( + SummaryResource, + AsyncSummaryResource, + SummaryResourceWithRawResponse, + AsyncSummaryResourceWithRawResponse, + SummaryResourceWithStreamingResponse, + AsyncSummaryResourceWithStreamingResponse, +) +from .timeseries_groups import ( + TimeseriesGroupsResource, + AsyncTimeseriesGroupsResource, + TimeseriesGroupsResourceWithRawResponse, + AsyncTimeseriesGroupsResourceWithRawResponse, + TimeseriesGroupsResourceWithStreamingResponse, + AsyncTimeseriesGroupsResourceWithStreamingResponse, +) __all__ = [ "TopResource", @@ -24,6 +40,18 @@ "AsyncTopResourceWithRawResponse", "TopResourceWithStreamingResponse", "AsyncTopResourceWithStreamingResponse", + "SummaryResource", + "AsyncSummaryResource", + "SummaryResourceWithRawResponse", + "AsyncSummaryResourceWithRawResponse", + "SummaryResourceWithStreamingResponse", + "AsyncSummaryResourceWithStreamingResponse", + "TimeseriesGroupsResource", + "AsyncTimeseriesGroupsResource", + "TimeseriesGroupsResourceWithRawResponse", + "AsyncTimeseriesGroupsResourceWithRawResponse", + "TimeseriesGroupsResourceWithStreamingResponse", + "AsyncTimeseriesGroupsResourceWithStreamingResponse", "DNSResource", "AsyncDNSResource", "DNSResourceWithRawResponse", diff --git a/src/cloudflare/resources/radar/dns/dns.py b/src/cloudflare/resources/radar/dns/dns.py index ca5b306d0bd..fe1fde542fa 100644 --- a/src/cloudflare/resources/radar/dns/dns.py +++ b/src/cloudflare/resources/radar/dns/dns.py @@ -2,6 +2,12 @@ from __future__ import annotations +from typing import List, Type, Union, Optional, cast +from datetime import datetime +from typing_extensions import Literal + +import httpx + from .top import ( TopResource, AsyncTopResource, @@ -10,8 +16,39 @@ TopResourceWithStreamingResponse, AsyncTopResourceWithStreamingResponse, ) +from .summary import ( + SummaryResource, + AsyncSummaryResource, + SummaryResourceWithRawResponse, + AsyncSummaryResourceWithRawResponse, + SummaryResourceWithStreamingResponse, + AsyncSummaryResourceWithStreamingResponse, +) +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.radar import dns_timeseries_params +from ...._base_client import make_request_options +from .timeseries_groups import ( + TimeseriesGroupsResource, + AsyncTimeseriesGroupsResource, + TimeseriesGroupsResourceWithRawResponse, + AsyncTimeseriesGroupsResourceWithRawResponse, + TimeseriesGroupsResourceWithStreamingResponse, + AsyncTimeseriesGroupsResourceWithStreamingResponse, +) +from ....types.radar.dns_timeseries_response import DNSTimeseriesResponse __all__ = ["DNSResource", "AsyncDNSResource"] @@ -21,6 +58,14 @@ class DNSResource(SyncAPIResource): def top(self) -> TopResource: return TopResource(self._client) + @cached_property + def summary(self) -> SummaryResource: + return SummaryResource(self._client) + + @cached_property + def timeseries_groups(self) -> TimeseriesGroupsResource: + return TimeseriesGroupsResource(self._client) + @cached_property def with_raw_response(self) -> DNSResourceWithRawResponse: """ @@ -40,12 +85,238 @@ def with_streaming_response(self) -> DNSResourceWithStreamingResponse: """ return DNSResourceWithStreamingResponse(self) + def timeseries( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> DNSTimeseriesResponse: + """ + Retrieves normalized query volume to the 1.1.1.1 DNS resolver over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + dns_timeseries_params.DNSTimeseriesParams, + ), + post_parser=ResultWrapper[DNSTimeseriesResponse]._unwrapper, + ), + cast_to=cast(Type[DNSTimeseriesResponse], ResultWrapper[DNSTimeseriesResponse]), + ) + class AsyncDNSResource(AsyncAPIResource): @cached_property def top(self) -> AsyncTopResource: return AsyncTopResource(self._client) + @cached_property + def summary(self) -> AsyncSummaryResource: + return AsyncSummaryResource(self._client) + + @cached_property + def timeseries_groups(self) -> AsyncTimeseriesGroupsResource: + return AsyncTimeseriesGroupsResource(self._client) + @cached_property def with_raw_response(self) -> AsyncDNSResourceWithRawResponse: """ @@ -65,38 +336,304 @@ def with_streaming_response(self) -> AsyncDNSResourceWithStreamingResponse: """ return AsyncDNSResourceWithStreamingResponse(self) + async def timeseries( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> DNSTimeseriesResponse: + """ + Retrieves normalized query volume to the 1.1.1.1 DNS resolver over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + dns_timeseries_params.DNSTimeseriesParams, + ), + post_parser=ResultWrapper[DNSTimeseriesResponse]._unwrapper, + ), + cast_to=cast(Type[DNSTimeseriesResponse], ResultWrapper[DNSTimeseriesResponse]), + ) + class DNSResourceWithRawResponse: def __init__(self, dns: DNSResource) -> None: self._dns = dns + self.timeseries = to_raw_response_wrapper( + dns.timeseries, + ) + @cached_property def top(self) -> TopResourceWithRawResponse: return TopResourceWithRawResponse(self._dns.top) + @cached_property + def summary(self) -> SummaryResourceWithRawResponse: + return SummaryResourceWithRawResponse(self._dns.summary) + + @cached_property + def timeseries_groups(self) -> TimeseriesGroupsResourceWithRawResponse: + return TimeseriesGroupsResourceWithRawResponse(self._dns.timeseries_groups) + class AsyncDNSResourceWithRawResponse: def __init__(self, dns: AsyncDNSResource) -> None: self._dns = dns + self.timeseries = async_to_raw_response_wrapper( + dns.timeseries, + ) + @cached_property def top(self) -> AsyncTopResourceWithRawResponse: return AsyncTopResourceWithRawResponse(self._dns.top) + @cached_property + def summary(self) -> AsyncSummaryResourceWithRawResponse: + return AsyncSummaryResourceWithRawResponse(self._dns.summary) + + @cached_property + def timeseries_groups(self) -> AsyncTimeseriesGroupsResourceWithRawResponse: + return AsyncTimeseriesGroupsResourceWithRawResponse(self._dns.timeseries_groups) + class DNSResourceWithStreamingResponse: def __init__(self, dns: DNSResource) -> None: self._dns = dns + self.timeseries = to_streamed_response_wrapper( + dns.timeseries, + ) + @cached_property def top(self) -> TopResourceWithStreamingResponse: return TopResourceWithStreamingResponse(self._dns.top) + @cached_property + def summary(self) -> SummaryResourceWithStreamingResponse: + return SummaryResourceWithStreamingResponse(self._dns.summary) + + @cached_property + def timeseries_groups(self) -> TimeseriesGroupsResourceWithStreamingResponse: + return TimeseriesGroupsResourceWithStreamingResponse(self._dns.timeseries_groups) + class AsyncDNSResourceWithStreamingResponse: def __init__(self, dns: AsyncDNSResource) -> None: self._dns = dns + self.timeseries = async_to_streamed_response_wrapper( + dns.timeseries, + ) + @cached_property def top(self) -> AsyncTopResourceWithStreamingResponse: return AsyncTopResourceWithStreamingResponse(self._dns.top) + + @cached_property + def summary(self) -> AsyncSummaryResourceWithStreamingResponse: + return AsyncSummaryResourceWithStreamingResponse(self._dns.summary) + + @cached_property + def timeseries_groups(self) -> AsyncTimeseriesGroupsResourceWithStreamingResponse: + return AsyncTimeseriesGroupsResourceWithStreamingResponse(self._dns.timeseries_groups) diff --git a/src/cloudflare/resources/radar/dns/summary.py b/src/cloudflare/resources/radar/dns/summary.py new file mode 100644 index 00000000000..1d21764ae4c --- /dev/null +++ b/src/cloudflare/resources/radar/dns/summary.py @@ -0,0 +1,4259 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Type, Union, Optional, cast +from datetime import datetime +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 ...._wrappers import ResultWrapper +from ...._base_client import make_request_options +from ....types.radar.dns import ( + summary_dnssec_params, + summary_protocol_params, + summary_cache_hit_params, + summary_dnssec_e2e_params, + summary_ip_version_params, + summary_query_type_params, + summary_dnssec_aware_params, + summary_response_ttl_params, + summary_response_code_params, + summary_matching_answer_params, +) +from ....types.radar.dns.summary_dnssec_response import SummaryDNSSECResponse +from ....types.radar.dns.summary_protocol_response import SummaryProtocolResponse +from ....types.radar.dns.summary_cache_hit_response import SummaryCacheHitResponse +from ....types.radar.dns.summary_dnssec_e2e_response import SummaryDNSSECE2EResponse +from ....types.radar.dns.summary_ip_version_response import SummaryIPVersionResponse +from ....types.radar.dns.summary_query_type_response import SummaryQueryTypeResponse +from ....types.radar.dns.summary_dnssec_aware_response import SummaryDNSSECAwareResponse +from ....types.radar.dns.summary_response_ttl_response import SummaryResponseTTLResponse +from ....types.radar.dns.summary_response_code_response import SummaryResponseCodeResponse +from ....types.radar.dns.summary_matching_answer_response import SummaryMatchingAnswerResponse + +__all__ = ["SummaryResource", "AsyncSummaryResource"] + + +class SummaryResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> SummaryResourceWithRawResponse: + """ + 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/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers + """ + return SummaryResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SummaryResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response + """ + return SummaryResourceWithStreamingResponse(self) + + def cache_hit( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryCacheHitResponse: + """ + Retrieves the distribution of DNS queries by cache status. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/cache_hit", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_cache_hit_params.SummaryCacheHitParams, + ), + post_parser=ResultWrapper[SummaryCacheHitResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryCacheHitResponse], ResultWrapper[SummaryCacheHitResponse]), + ) + + def dnssec( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryDNSSECResponse: + """ + Retrieves the distribution of DNS responses by DNSSEC (DNS Security Extensions) + support. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/dnssec", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_dnssec_params.SummaryDNSSECParams, + ), + post_parser=ResultWrapper[SummaryDNSSECResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryDNSSECResponse], ResultWrapper[SummaryDNSSECResponse]), + ) + + def dnssec_aware( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryDNSSECAwareResponse: + """ + Retrieves the distribution of DNS queries by DNSSEC (DNS Security Extensions) + client awareness. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/dnssec_aware", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_dnssec_aware_params.SummaryDNSSECAwareParams, + ), + post_parser=ResultWrapper[SummaryDNSSECAwareResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryDNSSECAwareResponse], ResultWrapper[SummaryDNSSECAwareResponse]), + ) + + def dnssec_e2e( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryDNSSECE2EResponse: + """ + Retrieves the distribution of DNSSEC-validated answers by end-to-end security + status. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/dnssec_e2e", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_dnssec_e2e_params.SummaryDNSSECE2EParams, + ), + post_parser=ResultWrapper[SummaryDNSSECE2EResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryDNSSECE2EResponse], ResultWrapper[SummaryDNSSECE2EResponse]), + ) + + def ip_version( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryIPVersionResponse: + """ + Retrieves the distribution of DNS queries by IP version. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/ip_version", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_ip_version_params.SummaryIPVersionParams, + ), + post_parser=ResultWrapper[SummaryIPVersionResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryIPVersionResponse], ResultWrapper[SummaryIPVersionResponse]), + ) + + def matching_answer( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryMatchingAnswerResponse: + """ + Retrieves the distribution of DNS queries by matching answers. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/matching_answer", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_matching_answer_params.SummaryMatchingAnswerParams, + ), + post_parser=ResultWrapper[SummaryMatchingAnswerResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryMatchingAnswerResponse], ResultWrapper[SummaryMatchingAnswerResponse]), + ) + + def protocol( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryProtocolResponse: + """ + Retrieves the distribution of DNS queries by DNS transport protocol. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/protocol", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_protocol_params.SummaryProtocolParams, + ), + post_parser=ResultWrapper[SummaryProtocolResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryProtocolResponse], ResultWrapper[SummaryProtocolResponse]), + ) + + def query_type( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryQueryTypeResponse: + """ + Retrieves the distribution of DNS queries by type. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/query_type", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "response_code": response_code, + "tld": tld, + }, + summary_query_type_params.SummaryQueryTypeParams, + ), + post_parser=ResultWrapper[SummaryQueryTypeResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryQueryTypeResponse], ResultWrapper[SummaryQueryTypeResponse]), + ) + + def response_code( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryResponseCodeResponse: + """ + Retrieves the distribution of DNS queries by response code. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/response_code", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "tld": tld, + }, + summary_response_code_params.SummaryResponseCodeParams, + ), + post_parser=ResultWrapper[SummaryResponseCodeResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryResponseCodeResponse], ResultWrapper[SummaryResponseCodeResponse]), + ) + + def response_ttl( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryResponseTTLResponse: + """ + Retrieves the distribution of DNS queries by minimum response TTL. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/summary/response_ttl", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_response_ttl_params.SummaryResponseTTLParams, + ), + post_parser=ResultWrapper[SummaryResponseTTLResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryResponseTTLResponse], ResultWrapper[SummaryResponseTTLResponse]), + ) + + +class AsyncSummaryResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncSummaryResourceWithRawResponse: + """ + 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/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers + """ + return AsyncSummaryResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSummaryResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response + """ + return AsyncSummaryResourceWithStreamingResponse(self) + + async def cache_hit( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryCacheHitResponse: + """ + Retrieves the distribution of DNS queries by cache status. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/cache_hit", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_cache_hit_params.SummaryCacheHitParams, + ), + post_parser=ResultWrapper[SummaryCacheHitResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryCacheHitResponse], ResultWrapper[SummaryCacheHitResponse]), + ) + + async def dnssec( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryDNSSECResponse: + """ + Retrieves the distribution of DNS responses by DNSSEC (DNS Security Extensions) + support. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/dnssec", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_dnssec_params.SummaryDNSSECParams, + ), + post_parser=ResultWrapper[SummaryDNSSECResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryDNSSECResponse], ResultWrapper[SummaryDNSSECResponse]), + ) + + async def dnssec_aware( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryDNSSECAwareResponse: + """ + Retrieves the distribution of DNS queries by DNSSEC (DNS Security Extensions) + client awareness. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/dnssec_aware", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_dnssec_aware_params.SummaryDNSSECAwareParams, + ), + post_parser=ResultWrapper[SummaryDNSSECAwareResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryDNSSECAwareResponse], ResultWrapper[SummaryDNSSECAwareResponse]), + ) + + async def dnssec_e2e( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryDNSSECE2EResponse: + """ + Retrieves the distribution of DNSSEC-validated answers by end-to-end security + status. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/dnssec_e2e", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_dnssec_e2e_params.SummaryDNSSECE2EParams, + ), + post_parser=ResultWrapper[SummaryDNSSECE2EResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryDNSSECE2EResponse], ResultWrapper[SummaryDNSSECE2EResponse]), + ) + + async def ip_version( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryIPVersionResponse: + """ + Retrieves the distribution of DNS queries by IP version. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/ip_version", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_ip_version_params.SummaryIPVersionParams, + ), + post_parser=ResultWrapper[SummaryIPVersionResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryIPVersionResponse], ResultWrapper[SummaryIPVersionResponse]), + ) + + async def matching_answer( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryMatchingAnswerResponse: + """ + Retrieves the distribution of DNS queries by matching answers. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/matching_answer", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_matching_answer_params.SummaryMatchingAnswerParams, + ), + post_parser=ResultWrapper[SummaryMatchingAnswerResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryMatchingAnswerResponse], ResultWrapper[SummaryMatchingAnswerResponse]), + ) + + async def protocol( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryProtocolResponse: + """ + Retrieves the distribution of DNS queries by DNS transport protocol. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/protocol", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_protocol_params.SummaryProtocolParams, + ), + post_parser=ResultWrapper[SummaryProtocolResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryProtocolResponse], ResultWrapper[SummaryProtocolResponse]), + ) + + async def query_type( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryQueryTypeResponse: + """ + Retrieves the distribution of DNS queries by type. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/query_type", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "response_code": response_code, + "tld": tld, + }, + summary_query_type_params.SummaryQueryTypeParams, + ), + post_parser=ResultWrapper[SummaryQueryTypeResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryQueryTypeResponse], ResultWrapper[SummaryQueryTypeResponse]), + ) + + async def response_code( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryResponseCodeResponse: + """ + Retrieves the distribution of DNS queries by response code. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/response_code", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "tld": tld, + }, + summary_response_code_params.SummaryResponseCodeParams, + ), + post_parser=ResultWrapper[SummaryResponseCodeResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryResponseCodeResponse], ResultWrapper[SummaryResponseCodeResponse]), + ) + + async def response_ttl( + self, + *, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> SummaryResponseTTLResponse: + """ + Retrieves the distribution of DNS queries by minimum response TTL. + + Args: + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/summary/response_ttl", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + summary_response_ttl_params.SummaryResponseTTLParams, + ), + post_parser=ResultWrapper[SummaryResponseTTLResponse]._unwrapper, + ), + cast_to=cast(Type[SummaryResponseTTLResponse], ResultWrapper[SummaryResponseTTLResponse]), + ) + + +class SummaryResourceWithRawResponse: + def __init__(self, summary: SummaryResource) -> None: + self._summary = summary + + self.cache_hit = to_raw_response_wrapper( + summary.cache_hit, + ) + self.dnssec = to_raw_response_wrapper( + summary.dnssec, + ) + self.dnssec_aware = to_raw_response_wrapper( + summary.dnssec_aware, + ) + self.dnssec_e2e = to_raw_response_wrapper( + summary.dnssec_e2e, + ) + self.ip_version = to_raw_response_wrapper( + summary.ip_version, + ) + self.matching_answer = to_raw_response_wrapper( + summary.matching_answer, + ) + self.protocol = to_raw_response_wrapper( + summary.protocol, + ) + self.query_type = to_raw_response_wrapper( + summary.query_type, + ) + self.response_code = to_raw_response_wrapper( + summary.response_code, + ) + self.response_ttl = to_raw_response_wrapper( + summary.response_ttl, + ) + + +class AsyncSummaryResourceWithRawResponse: + def __init__(self, summary: AsyncSummaryResource) -> None: + self._summary = summary + + self.cache_hit = async_to_raw_response_wrapper( + summary.cache_hit, + ) + self.dnssec = async_to_raw_response_wrapper( + summary.dnssec, + ) + self.dnssec_aware = async_to_raw_response_wrapper( + summary.dnssec_aware, + ) + self.dnssec_e2e = async_to_raw_response_wrapper( + summary.dnssec_e2e, + ) + self.ip_version = async_to_raw_response_wrapper( + summary.ip_version, + ) + self.matching_answer = async_to_raw_response_wrapper( + summary.matching_answer, + ) + self.protocol = async_to_raw_response_wrapper( + summary.protocol, + ) + self.query_type = async_to_raw_response_wrapper( + summary.query_type, + ) + self.response_code = async_to_raw_response_wrapper( + summary.response_code, + ) + self.response_ttl = async_to_raw_response_wrapper( + summary.response_ttl, + ) + + +class SummaryResourceWithStreamingResponse: + def __init__(self, summary: SummaryResource) -> None: + self._summary = summary + + self.cache_hit = to_streamed_response_wrapper( + summary.cache_hit, + ) + self.dnssec = to_streamed_response_wrapper( + summary.dnssec, + ) + self.dnssec_aware = to_streamed_response_wrapper( + summary.dnssec_aware, + ) + self.dnssec_e2e = to_streamed_response_wrapper( + summary.dnssec_e2e, + ) + self.ip_version = to_streamed_response_wrapper( + summary.ip_version, + ) + self.matching_answer = to_streamed_response_wrapper( + summary.matching_answer, + ) + self.protocol = to_streamed_response_wrapper( + summary.protocol, + ) + self.query_type = to_streamed_response_wrapper( + summary.query_type, + ) + self.response_code = to_streamed_response_wrapper( + summary.response_code, + ) + self.response_ttl = to_streamed_response_wrapper( + summary.response_ttl, + ) + + +class AsyncSummaryResourceWithStreamingResponse: + def __init__(self, summary: AsyncSummaryResource) -> None: + self._summary = summary + + self.cache_hit = async_to_streamed_response_wrapper( + summary.cache_hit, + ) + self.dnssec = async_to_streamed_response_wrapper( + summary.dnssec, + ) + self.dnssec_aware = async_to_streamed_response_wrapper( + summary.dnssec_aware, + ) + self.dnssec_e2e = async_to_streamed_response_wrapper( + summary.dnssec_e2e, + ) + self.ip_version = async_to_streamed_response_wrapper( + summary.ip_version, + ) + self.matching_answer = async_to_streamed_response_wrapper( + summary.matching_answer, + ) + self.protocol = async_to_streamed_response_wrapper( + summary.protocol, + ) + self.query_type = async_to_streamed_response_wrapper( + summary.query_type, + ) + self.response_code = async_to_streamed_response_wrapper( + summary.response_code, + ) + self.response_ttl = async_to_streamed_response_wrapper( + summary.response_ttl, + ) diff --git a/src/cloudflare/resources/radar/dns/timeseries_groups.py b/src/cloudflare/resources/radar/dns/timeseries_groups.py new file mode 100644 index 00000000000..e5bd40a7dd2 --- /dev/null +++ b/src/cloudflare/resources/radar/dns/timeseries_groups.py @@ -0,0 +1,4383 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Type, Union, Optional, cast +from datetime import datetime +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 ...._wrappers import ResultWrapper +from ...._base_client import make_request_options +from ....types.radar.dns import ( + timeseries_group_dnssec_params, + timeseries_group_protocol_params, + timeseries_group_cache_hit_params, + timeseries_group_dnssec_e2e_params, + timeseries_group_ip_version_params, + timeseries_group_query_type_params, + timeseries_group_dnssec_aware_params, + timeseries_group_response_ttl_params, + timeseries_group_response_code_params, + timeseries_group_matching_answer_params, +) +from ....types.radar.dns.timeseries_group_dnssec_response import TimeseriesGroupDNSSECResponse +from ....types.radar.dns.timeseries_group_protocol_response import TimeseriesGroupProtocolResponse +from ....types.radar.dns.timeseries_group_cache_hit_response import TimeseriesGroupCacheHitResponse +from ....types.radar.dns.timeseries_group_dnssec_e2e_response import TimeseriesGroupDNSSECE2EResponse +from ....types.radar.dns.timeseries_group_ip_version_response import TimeseriesGroupIPVersionResponse +from ....types.radar.dns.timeseries_group_query_type_response import TimeseriesGroupQueryTypeResponse +from ....types.radar.dns.timeseries_group_dnssec_aware_response import TimeseriesGroupDNSSECAwareResponse +from ....types.radar.dns.timeseries_group_response_ttl_response import TimeseriesGroupResponseTTLResponse +from ....types.radar.dns.timeseries_group_response_code_response import TimeseriesGroupResponseCodeResponse +from ....types.radar.dns.timeseries_group_matching_answer_response import TimeseriesGroupMatchingAnswerResponse + +__all__ = ["TimeseriesGroupsResource", "AsyncTimeseriesGroupsResource"] + + +class TimeseriesGroupsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> TimeseriesGroupsResourceWithRawResponse: + """ + 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/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers + """ + return TimeseriesGroupsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> TimeseriesGroupsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response + """ + return TimeseriesGroupsResourceWithStreamingResponse(self) + + def cache_hit( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupCacheHitResponse: + """ + Retrieves the distribution of DNS queries by cache status over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/cache_hit", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_cache_hit_params.TimeseriesGroupCacheHitParams, + ), + post_parser=ResultWrapper[TimeseriesGroupCacheHitResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupCacheHitResponse], ResultWrapper[TimeseriesGroupCacheHitResponse]), + ) + + def dnssec( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupDNSSECResponse: + """ + Retrieves the distribution of DNS responses by DNSSEC (DNS Security Extensions) + support over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/dnssec", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_dnssec_params.TimeseriesGroupDNSSECParams, + ), + post_parser=ResultWrapper[TimeseriesGroupDNSSECResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupDNSSECResponse], ResultWrapper[TimeseriesGroupDNSSECResponse]), + ) + + def dnssec_aware( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupDNSSECAwareResponse: + """ + Retrieves the distribution of DNS queries by DNSSEC (DNS Security Extensions) + client awareness over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/dnssec_aware", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_dnssec_aware_params.TimeseriesGroupDNSSECAwareParams, + ), + post_parser=ResultWrapper[TimeseriesGroupDNSSECAwareResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupDNSSECAwareResponse], ResultWrapper[TimeseriesGroupDNSSECAwareResponse]), + ) + + def dnssec_e2e( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupDNSSECE2EResponse: + """ + Retrieves the distribution of DNSSEC-validated answers by end-to-end security + status over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/dnssec_e2e", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_dnssec_e2e_params.TimeseriesGroupDNSSECE2EParams, + ), + post_parser=ResultWrapper[TimeseriesGroupDNSSECE2EResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupDNSSECE2EResponse], ResultWrapper[TimeseriesGroupDNSSECE2EResponse]), + ) + + def ip_version( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupIPVersionResponse: + """ + Retrieves the distribution of DNS queries by IP version over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/ip_version", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_ip_version_params.TimeseriesGroupIPVersionParams, + ), + post_parser=ResultWrapper[TimeseriesGroupIPVersionResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupIPVersionResponse], ResultWrapper[TimeseriesGroupIPVersionResponse]), + ) + + def matching_answer( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupMatchingAnswerResponse: + """ + Retrieves the distribution of DNS queries by matching answers over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/matching_answer", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_matching_answer_params.TimeseriesGroupMatchingAnswerParams, + ), + post_parser=ResultWrapper[TimeseriesGroupMatchingAnswerResponse]._unwrapper, + ), + cast_to=cast( + Type[TimeseriesGroupMatchingAnswerResponse], ResultWrapper[TimeseriesGroupMatchingAnswerResponse] + ), + ) + + def protocol( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupProtocolResponse: + """ + Retrieves the distribution of DNS queries by DNS transport protocol over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/protocol", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_protocol_params.TimeseriesGroupProtocolParams, + ), + post_parser=ResultWrapper[TimeseriesGroupProtocolResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupProtocolResponse], ResultWrapper[TimeseriesGroupProtocolResponse]), + ) + + def query_type( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupQueryTypeResponse: + """ + Retrieves the distribution of DNS queries by type over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/query_type", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_query_type_params.TimeseriesGroupQueryTypeParams, + ), + post_parser=ResultWrapper[TimeseriesGroupQueryTypeResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupQueryTypeResponse], ResultWrapper[TimeseriesGroupQueryTypeResponse]), + ) + + def response_code( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupResponseCodeResponse: + """ + Retrieves the distribution of DNS queries by response code over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/response_code", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "tld": tld, + }, + timeseries_group_response_code_params.TimeseriesGroupResponseCodeParams, + ), + post_parser=ResultWrapper[TimeseriesGroupResponseCodeResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupResponseCodeResponse], ResultWrapper[TimeseriesGroupResponseCodeResponse]), + ) + + def response_ttl( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupResponseTTLResponse: + """ + Retrieves the distribution of DNS queries by minimum answer TTL over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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( + "/radar/dns/timeseries_groups/response_ttl", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_response_ttl_params.TimeseriesGroupResponseTTLParams, + ), + post_parser=ResultWrapper[TimeseriesGroupResponseTTLResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupResponseTTLResponse], ResultWrapper[TimeseriesGroupResponseTTLResponse]), + ) + + +class AsyncTimeseriesGroupsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncTimeseriesGroupsResourceWithRawResponse: + """ + 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/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers + """ + return AsyncTimeseriesGroupsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncTimeseriesGroupsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response + """ + return AsyncTimeseriesGroupsResourceWithStreamingResponse(self) + + async def cache_hit( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupCacheHitResponse: + """ + Retrieves the distribution of DNS queries by cache status over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/cache_hit", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_cache_hit_params.TimeseriesGroupCacheHitParams, + ), + post_parser=ResultWrapper[TimeseriesGroupCacheHitResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupCacheHitResponse], ResultWrapper[TimeseriesGroupCacheHitResponse]), + ) + + async def dnssec( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupDNSSECResponse: + """ + Retrieves the distribution of DNS responses by DNSSEC (DNS Security Extensions) + support over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/dnssec", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_dnssec_params.TimeseriesGroupDNSSECParams, + ), + post_parser=ResultWrapper[TimeseriesGroupDNSSECResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupDNSSECResponse], ResultWrapper[TimeseriesGroupDNSSECResponse]), + ) + + async def dnssec_aware( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupDNSSECAwareResponse: + """ + Retrieves the distribution of DNS queries by DNSSEC (DNS Security Extensions) + client awareness over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/dnssec_aware", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_dnssec_aware_params.TimeseriesGroupDNSSECAwareParams, + ), + post_parser=ResultWrapper[TimeseriesGroupDNSSECAwareResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupDNSSECAwareResponse], ResultWrapper[TimeseriesGroupDNSSECAwareResponse]), + ) + + async def dnssec_e2e( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupDNSSECE2EResponse: + """ + Retrieves the distribution of DNSSEC-validated answers by end-to-end security + status over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/dnssec_e2e", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_dnssec_e2e_params.TimeseriesGroupDNSSECE2EParams, + ), + post_parser=ResultWrapper[TimeseriesGroupDNSSECE2EResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupDNSSECE2EResponse], ResultWrapper[TimeseriesGroupDNSSECE2EResponse]), + ) + + async def ip_version( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupIPVersionResponse: + """ + Retrieves the distribution of DNS queries by IP version over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/ip_version", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_ip_version_params.TimeseriesGroupIPVersionParams, + ), + post_parser=ResultWrapper[TimeseriesGroupIPVersionResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupIPVersionResponse], ResultWrapper[TimeseriesGroupIPVersionResponse]), + ) + + async def matching_answer( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupMatchingAnswerResponse: + """ + Retrieves the distribution of DNS queries by matching answers over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/matching_answer", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_matching_answer_params.TimeseriesGroupMatchingAnswerParams, + ), + post_parser=ResultWrapper[TimeseriesGroupMatchingAnswerResponse]._unwrapper, + ), + cast_to=cast( + Type[TimeseriesGroupMatchingAnswerResponse], ResultWrapper[TimeseriesGroupMatchingAnswerResponse] + ), + ) + + async def protocol( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupProtocolResponse: + """ + Retrieves the distribution of DNS queries by DNS transport protocol over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/protocol", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_protocol_params.TimeseriesGroupProtocolParams, + ), + post_parser=ResultWrapper[TimeseriesGroupProtocolResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupProtocolResponse], ResultWrapper[TimeseriesGroupProtocolResponse]), + ) + + async def query_type( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupQueryTypeResponse: + """ + Retrieves the distribution of DNS queries by type over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/query_type", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_query_type_params.TimeseriesGroupQueryTypeParams, + ), + post_parser=ResultWrapper[TimeseriesGroupQueryTypeResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupQueryTypeResponse], ResultWrapper[TimeseriesGroupQueryTypeResponse]), + ) + + async def response_code( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit_per_group: int | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupResponseCodeResponse: + """ + Retrieves the distribution of DNS queries by response code over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + limit_per_group: Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/response_code", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "limit_per_group": limit_per_group, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "tld": tld, + }, + timeseries_group_response_code_params.TimeseriesGroupResponseCodeParams, + ), + post_parser=ResultWrapper[TimeseriesGroupResponseCodeResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupResponseCodeResponse], ResultWrapper[TimeseriesGroupResponseCodeResponse]), + ) + + async def response_ttl( + self, + *, + agg_interval: Literal["15m", "1h", "1d", "1w"] | NotGiven = NOT_GIVEN, + asn: List[str] | NotGiven = NOT_GIVEN, + continent: List[str] | NotGiven = NOT_GIVEN, + date_end: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + date_range: List[str] | NotGiven = NOT_GIVEN, + date_start: List[Union[str, datetime]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + location: List[str] | NotGiven = NOT_GIVEN, + name: List[str] | NotGiven = NOT_GIVEN, + nodata: bool | NotGiven = NOT_GIVEN, + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] | NotGiven = NOT_GIVEN, + query_type: Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ] + | NotGiven = NOT_GIVEN, + response_code: Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ] + | NotGiven = NOT_GIVEN, + tld: List[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, + ) -> TimeseriesGroupResponseTTLResponse: + """ + Retrieves the distribution of DNS queries by minimum answer TTL over time. + + Args: + agg_interval: Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + + asn: Comma-separated list of Autonomous System Numbers (ASNs). Prefix with `-` to + exclude ASNs from results. For example, `-174, 3356` excludes results from + AS174, but includes results from AS3356. + + continent: Comma-separated list of continents (alpha-2 continent codes). Prefix with `-` to + exclude continents from results. For example, `-EU,NA` excludes results from EU, + but includes results from NA. + + date_end: End of the date range (inclusive). + + date_range: Filters results by the specified date range. For example, use `7d` and + `7dcontrol` to compare this week with the previous week. Use this parameter or + set specific start and end dates (`dateStart` and `dateEnd` parameters). + + date_start: Start of the date range. + + format: Format in which results will be returned. + + location: Comma-separated list of locations (alpha-2 codes). Prefix with `-` to exclude + locations from results. For example, `-US,PT` excludes results from the US, but + includes results from PT. + + name: Array of names used to label the series in the response. + + nodata: Includes empty DNS responses (NODATA). + + protocol: Filters results by DNS transport protocol. + + query_type: Filters results by DNS query type. + + response_code: Filters results by DNS response code. + + tld: Filters results by country code top-level domain (ccTLD). + + 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._get( + "/radar/dns/timeseries_groups/response_ttl", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "agg_interval": agg_interval, + "asn": asn, + "continent": continent, + "date_end": date_end, + "date_range": date_range, + "date_start": date_start, + "format": format, + "location": location, + "name": name, + "nodata": nodata, + "protocol": protocol, + "query_type": query_type, + "response_code": response_code, + "tld": tld, + }, + timeseries_group_response_ttl_params.TimeseriesGroupResponseTTLParams, + ), + post_parser=ResultWrapper[TimeseriesGroupResponseTTLResponse]._unwrapper, + ), + cast_to=cast(Type[TimeseriesGroupResponseTTLResponse], ResultWrapper[TimeseriesGroupResponseTTLResponse]), + ) + + +class TimeseriesGroupsResourceWithRawResponse: + def __init__(self, timeseries_groups: TimeseriesGroupsResource) -> None: + self._timeseries_groups = timeseries_groups + + self.cache_hit = to_raw_response_wrapper( + timeseries_groups.cache_hit, + ) + self.dnssec = to_raw_response_wrapper( + timeseries_groups.dnssec, + ) + self.dnssec_aware = to_raw_response_wrapper( + timeseries_groups.dnssec_aware, + ) + self.dnssec_e2e = to_raw_response_wrapper( + timeseries_groups.dnssec_e2e, + ) + self.ip_version = to_raw_response_wrapper( + timeseries_groups.ip_version, + ) + self.matching_answer = to_raw_response_wrapper( + timeseries_groups.matching_answer, + ) + self.protocol = to_raw_response_wrapper( + timeseries_groups.protocol, + ) + self.query_type = to_raw_response_wrapper( + timeseries_groups.query_type, + ) + self.response_code = to_raw_response_wrapper( + timeseries_groups.response_code, + ) + self.response_ttl = to_raw_response_wrapper( + timeseries_groups.response_ttl, + ) + + +class AsyncTimeseriesGroupsResourceWithRawResponse: + def __init__(self, timeseries_groups: AsyncTimeseriesGroupsResource) -> None: + self._timeseries_groups = timeseries_groups + + self.cache_hit = async_to_raw_response_wrapper( + timeseries_groups.cache_hit, + ) + self.dnssec = async_to_raw_response_wrapper( + timeseries_groups.dnssec, + ) + self.dnssec_aware = async_to_raw_response_wrapper( + timeseries_groups.dnssec_aware, + ) + self.dnssec_e2e = async_to_raw_response_wrapper( + timeseries_groups.dnssec_e2e, + ) + self.ip_version = async_to_raw_response_wrapper( + timeseries_groups.ip_version, + ) + self.matching_answer = async_to_raw_response_wrapper( + timeseries_groups.matching_answer, + ) + self.protocol = async_to_raw_response_wrapper( + timeseries_groups.protocol, + ) + self.query_type = async_to_raw_response_wrapper( + timeseries_groups.query_type, + ) + self.response_code = async_to_raw_response_wrapper( + timeseries_groups.response_code, + ) + self.response_ttl = async_to_raw_response_wrapper( + timeseries_groups.response_ttl, + ) + + +class TimeseriesGroupsResourceWithStreamingResponse: + def __init__(self, timeseries_groups: TimeseriesGroupsResource) -> None: + self._timeseries_groups = timeseries_groups + + self.cache_hit = to_streamed_response_wrapper( + timeseries_groups.cache_hit, + ) + self.dnssec = to_streamed_response_wrapper( + timeseries_groups.dnssec, + ) + self.dnssec_aware = to_streamed_response_wrapper( + timeseries_groups.dnssec_aware, + ) + self.dnssec_e2e = to_streamed_response_wrapper( + timeseries_groups.dnssec_e2e, + ) + self.ip_version = to_streamed_response_wrapper( + timeseries_groups.ip_version, + ) + self.matching_answer = to_streamed_response_wrapper( + timeseries_groups.matching_answer, + ) + self.protocol = to_streamed_response_wrapper( + timeseries_groups.protocol, + ) + self.query_type = to_streamed_response_wrapper( + timeseries_groups.query_type, + ) + self.response_code = to_streamed_response_wrapper( + timeseries_groups.response_code, + ) + self.response_ttl = to_streamed_response_wrapper( + timeseries_groups.response_ttl, + ) + + +class AsyncTimeseriesGroupsResourceWithStreamingResponse: + def __init__(self, timeseries_groups: AsyncTimeseriesGroupsResource) -> None: + self._timeseries_groups = timeseries_groups + + self.cache_hit = async_to_streamed_response_wrapper( + timeseries_groups.cache_hit, + ) + self.dnssec = async_to_streamed_response_wrapper( + timeseries_groups.dnssec, + ) + self.dnssec_aware = async_to_streamed_response_wrapper( + timeseries_groups.dnssec_aware, + ) + self.dnssec_e2e = async_to_streamed_response_wrapper( + timeseries_groups.dnssec_e2e, + ) + self.ip_version = async_to_streamed_response_wrapper( + timeseries_groups.ip_version, + ) + self.matching_answer = async_to_streamed_response_wrapper( + timeseries_groups.matching_answer, + ) + self.protocol = async_to_streamed_response_wrapper( + timeseries_groups.protocol, + ) + self.query_type = async_to_streamed_response_wrapper( + timeseries_groups.query_type, + ) + self.response_code = async_to_streamed_response_wrapper( + timeseries_groups.response_code, + ) + self.response_ttl = async_to_streamed_response_wrapper( + timeseries_groups.response_ttl, + ) diff --git a/src/cloudflare/resources/radar/ranking/internet_services.py b/src/cloudflare/resources/radar/ranking/internet_services.py index f604a2daf48..24436b176ad 100644 --- a/src/cloudflare/resources/radar/ranking/internet_services.py +++ b/src/cloudflare/resources/radar/ranking/internet_services.py @@ -23,8 +23,13 @@ ) from ...._wrappers import ResultWrapper from ...._base_client import make_request_options -from ....types.radar.ranking import internet_service_top_params, internet_service_timeseries_groups_params +from ....types.radar.ranking import ( + internet_service_top_params, + internet_service_categories_params, + internet_service_timeseries_groups_params, +) from ....types.radar.ranking.internet_service_top_response import InternetServiceTopResponse +from ....types.radar.ranking.internet_service_categories_response import InternetServiceCategoriesResponse from ....types.radar.ranking.internet_service_timeseries_groups_response import InternetServiceTimeseriesGroupsResponse __all__ = ["InternetServicesResource", "AsyncInternetServicesResource"] @@ -50,6 +55,61 @@ def with_streaming_response(self) -> InternetServicesResourceWithStreamingRespon """ return InternetServicesResourceWithStreamingResponse(self) + def categories( + self, + *, + date: List[Union[str, date]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit: int | NotGiven = NOT_GIVEN, + name: List[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, + ) -> InternetServiceCategoriesResponse: + """ + Retrieves the list of Internet services categories. + + Args: + date: Array of dates to filter the ranking. + + format: Format in which results will be returned. + + limit: Limits the number of objects returned in the response. + + name: Array of names used to label the series in the response. + + 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( + "/radar/ranking/internet_services/categories", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "date": date, + "format": format, + "limit": limit, + "name": name, + }, + internet_service_categories_params.InternetServiceCategoriesParams, + ), + post_parser=ResultWrapper[InternetServiceCategoriesResponse]._unwrapper, + ), + cast_to=cast(Type[InternetServiceCategoriesResponse], ResultWrapper[InternetServiceCategoriesResponse]), + ) + def timeseries_groups( self, *, @@ -201,6 +261,61 @@ def with_streaming_response(self) -> AsyncInternetServicesResourceWithStreamingR """ return AsyncInternetServicesResourceWithStreamingResponse(self) + async def categories( + self, + *, + date: List[Union[str, date]] | NotGiven = NOT_GIVEN, + format: Literal["JSON", "CSV"] | NotGiven = NOT_GIVEN, + limit: int | NotGiven = NOT_GIVEN, + name: List[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, + ) -> InternetServiceCategoriesResponse: + """ + Retrieves the list of Internet services categories. + + Args: + date: Array of dates to filter the ranking. + + format: Format in which results will be returned. + + limit: Limits the number of objects returned in the response. + + name: Array of names used to label the series in the response. + + 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._get( + "/radar/ranking/internet_services/categories", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "date": date, + "format": format, + "limit": limit, + "name": name, + }, + internet_service_categories_params.InternetServiceCategoriesParams, + ), + post_parser=ResultWrapper[InternetServiceCategoriesResponse]._unwrapper, + ), + cast_to=cast(Type[InternetServiceCategoriesResponse], ResultWrapper[InternetServiceCategoriesResponse]), + ) + async def timeseries_groups( self, *, @@ -336,6 +451,9 @@ class InternetServicesResourceWithRawResponse: def __init__(self, internet_services: InternetServicesResource) -> None: self._internet_services = internet_services + self.categories = to_raw_response_wrapper( + internet_services.categories, + ) self.timeseries_groups = to_raw_response_wrapper( internet_services.timeseries_groups, ) @@ -348,6 +466,9 @@ class AsyncInternetServicesResourceWithRawResponse: def __init__(self, internet_services: AsyncInternetServicesResource) -> None: self._internet_services = internet_services + self.categories = async_to_raw_response_wrapper( + internet_services.categories, + ) self.timeseries_groups = async_to_raw_response_wrapper( internet_services.timeseries_groups, ) @@ -360,6 +481,9 @@ class InternetServicesResourceWithStreamingResponse: def __init__(self, internet_services: InternetServicesResource) -> None: self._internet_services = internet_services + self.categories = to_streamed_response_wrapper( + internet_services.categories, + ) self.timeseries_groups = to_streamed_response_wrapper( internet_services.timeseries_groups, ) @@ -372,6 +496,9 @@ class AsyncInternetServicesResourceWithStreamingResponse: def __init__(self, internet_services: AsyncInternetServicesResource) -> None: self._internet_services = internet_services + self.categories = async_to_streamed_response_wrapper( + internet_services.categories, + ) self.timeseries_groups = async_to_streamed_response_wrapper( internet_services.timeseries_groups, ) diff --git a/src/cloudflare/types/radar/__init__.py b/src/cloudflare/types/radar/__init__.py index 1d559930f7b..d2ee6584473 100644 --- a/src/cloudflare/types/radar/__init__.py +++ b/src/cloudflare/types/radar/__init__.py @@ -13,6 +13,7 @@ from .search_global_params import SearchGlobalParams as SearchGlobalParams from .bgp_timeseries_params import BGPTimeseriesParams as BGPTimeseriesParams from .dataset_list_response import DatasetListResponse as DatasetListResponse +from .dns_timeseries_params import DNSTimeseriesParams as DNSTimeseriesParams from .annotation_list_params import AnnotationListParams as AnnotationListParams from .http_timeseries_params import HTTPTimeseriesParams as HTTPTimeseriesParams from .netflow_summary_params import NetflowSummaryParams as NetflowSummaryParams @@ -20,6 +21,7 @@ from .as112_timeseries_params import AS112TimeseriesParams as AS112TimeseriesParams from .bgp_timeseries_response import BGPTimeseriesResponse as BGPTimeseriesResponse from .dataset_download_params import DatasetDownloadParams as DatasetDownloadParams +from .dns_timeseries_response import DNSTimeseriesResponse as DNSTimeseriesResponse from .annotation_list_response import AnnotationListResponse as AnnotationListResponse from .http_timeseries_response import HTTPTimeseriesResponse as HTTPTimeseriesResponse from .netflow_summary_response import NetflowSummaryResponse as NetflowSummaryResponse diff --git a/src/cloudflare/types/radar/dns/__init__.py b/src/cloudflare/types/radar/dns/__init__.py index 4bc84848b71..365ed97b1e0 100644 --- a/src/cloudflare/types/radar/dns/__init__.py +++ b/src/cloudflare/types/radar/dns/__init__.py @@ -5,4 +5,56 @@ from .top_ases_params import TopAsesParams as TopAsesParams from .top_ases_response import TopAsesResponse as TopAsesResponse from .top_locations_params import TopLocationsParams as TopLocationsParams +from .summary_dnssec_params import SummaryDNSSECParams as SummaryDNSSECParams from .top_locations_response import TopLocationsResponse as TopLocationsResponse +from .summary_dnssec_response import SummaryDNSSECResponse as SummaryDNSSECResponse +from .summary_protocol_params import SummaryProtocolParams as SummaryProtocolParams +from .summary_cache_hit_params import SummaryCacheHitParams as SummaryCacheHitParams +from .summary_dnssec_e2e_params import SummaryDNSSECE2EParams as SummaryDNSSECE2EParams +from .summary_ip_version_params import SummaryIPVersionParams as SummaryIPVersionParams +from .summary_protocol_response import SummaryProtocolResponse as SummaryProtocolResponse +from .summary_query_type_params import SummaryQueryTypeParams as SummaryQueryTypeParams +from .summary_cache_hit_response import SummaryCacheHitResponse as SummaryCacheHitResponse +from .summary_dnssec_aware_params import SummaryDNSSECAwareParams as SummaryDNSSECAwareParams +from .summary_dnssec_e2e_response import SummaryDNSSECE2EResponse as SummaryDNSSECE2EResponse +from .summary_ip_version_response import SummaryIPVersionResponse as SummaryIPVersionResponse +from .summary_query_type_response import SummaryQueryTypeResponse as SummaryQueryTypeResponse +from .summary_response_ttl_params import SummaryResponseTTLParams as SummaryResponseTTLParams +from .summary_response_code_params import SummaryResponseCodeParams as SummaryResponseCodeParams +from .summary_dnssec_aware_response import SummaryDNSSECAwareResponse as SummaryDNSSECAwareResponse +from .summary_response_ttl_response import SummaryResponseTTLResponse as SummaryResponseTTLResponse +from .summary_matching_answer_params import SummaryMatchingAnswerParams as SummaryMatchingAnswerParams +from .summary_response_code_response import SummaryResponseCodeResponse as SummaryResponseCodeResponse +from .timeseries_group_dnssec_params import TimeseriesGroupDNSSECParams as TimeseriesGroupDNSSECParams +from .summary_matching_answer_response import SummaryMatchingAnswerResponse as SummaryMatchingAnswerResponse +from .timeseries_group_dnssec_response import TimeseriesGroupDNSSECResponse as TimeseriesGroupDNSSECResponse +from .timeseries_group_protocol_params import TimeseriesGroupProtocolParams as TimeseriesGroupProtocolParams +from .timeseries_group_cache_hit_params import TimeseriesGroupCacheHitParams as TimeseriesGroupCacheHitParams +from .timeseries_group_dnssec_e2e_params import TimeseriesGroupDNSSECE2EParams as TimeseriesGroupDNSSECE2EParams +from .timeseries_group_ip_version_params import TimeseriesGroupIPVersionParams as TimeseriesGroupIPVersionParams +from .timeseries_group_protocol_response import TimeseriesGroupProtocolResponse as TimeseriesGroupProtocolResponse +from .timeseries_group_query_type_params import TimeseriesGroupQueryTypeParams as TimeseriesGroupQueryTypeParams +from .timeseries_group_cache_hit_response import TimeseriesGroupCacheHitResponse as TimeseriesGroupCacheHitResponse +from .timeseries_group_dnssec_aware_params import TimeseriesGroupDNSSECAwareParams as TimeseriesGroupDNSSECAwareParams +from .timeseries_group_dnssec_e2e_response import TimeseriesGroupDNSSECE2EResponse as TimeseriesGroupDNSSECE2EResponse +from .timeseries_group_ip_version_response import TimeseriesGroupIPVersionResponse as TimeseriesGroupIPVersionResponse +from .timeseries_group_query_type_response import TimeseriesGroupQueryTypeResponse as TimeseriesGroupQueryTypeResponse +from .timeseries_group_response_ttl_params import TimeseriesGroupResponseTTLParams as TimeseriesGroupResponseTTLParams +from .timeseries_group_response_code_params import ( + TimeseriesGroupResponseCodeParams as TimeseriesGroupResponseCodeParams, +) +from .timeseries_group_dnssec_aware_response import ( + TimeseriesGroupDNSSECAwareResponse as TimeseriesGroupDNSSECAwareResponse, +) +from .timeseries_group_response_ttl_response import ( + TimeseriesGroupResponseTTLResponse as TimeseriesGroupResponseTTLResponse, +) +from .timeseries_group_matching_answer_params import ( + TimeseriesGroupMatchingAnswerParams as TimeseriesGroupMatchingAnswerParams, +) +from .timeseries_group_response_code_response import ( + TimeseriesGroupResponseCodeResponse as TimeseriesGroupResponseCodeResponse, +) +from .timeseries_group_matching_answer_response import ( + TimeseriesGroupMatchingAnswerResponse as TimeseriesGroupMatchingAnswerResponse, +) diff --git a/src/cloudflare/types/radar/dns/summary_cache_hit_params.py b/src/cloudflare/types/radar/dns/summary_cache_hit_params.py new file mode 100644 index 00000000000..543ebd100be --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_cache_hit_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryCacheHitParams"] + + +class SummaryCacheHitParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_cache_hit_response.py b/src/cloudflare/types/radar/dns/summary_cache_hit_response.py new file mode 100644 index 00000000000..eac77027ab9 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_cache_hit_response.py @@ -0,0 +1,69 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryCacheHitResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + negative: str = FieldInfo(alias="NEGATIVE") + + positive: str = FieldInfo(alias="POSITIVE") + + +class SummaryCacheHitResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_dnssec_aware_params.py b/src/cloudflare/types/radar/dns/summary_dnssec_aware_params.py new file mode 100644 index 00000000000..070fce53a7e --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_dnssec_aware_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryDNSSECAwareParams"] + + +class SummaryDNSSECAwareParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_dnssec_aware_response.py b/src/cloudflare/types/radar/dns/summary_dnssec_aware_response.py new file mode 100644 index 00000000000..d31274b80f9 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_dnssec_aware_response.py @@ -0,0 +1,69 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryDNSSECAwareResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + not_supported: str = FieldInfo(alias="NOT_SUPPORTED") + + supported: str = FieldInfo(alias="SUPPORTED") + + +class SummaryDNSSECAwareResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_dnssec_e2e_params.py b/src/cloudflare/types/radar/dns/summary_dnssec_e2e_params.py new file mode 100644 index 00000000000..c628d84bc9b --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_dnssec_e2e_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryDNSSECE2EParams"] + + +class SummaryDNSSECE2EParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_dnssec_e2e_response.py b/src/cloudflare/types/radar/dns/summary_dnssec_e2e_response.py new file mode 100644 index 00000000000..09b86fac10c --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_dnssec_e2e_response.py @@ -0,0 +1,69 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryDNSSECE2EResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + negative: str = FieldInfo(alias="NEGATIVE") + + positive: str = FieldInfo(alias="POSITIVE") + + +class SummaryDNSSECE2EResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_dnssec_params.py b/src/cloudflare/types/radar/dns/summary_dnssec_params.py new file mode 100644 index 00000000000..14227b4eae5 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_dnssec_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryDNSSECParams"] + + +class SummaryDNSSECParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_dnssec_response.py b/src/cloudflare/types/radar/dns/summary_dnssec_response.py new file mode 100644 index 00000000000..a4f7393ab7f --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_dnssec_response.py @@ -0,0 +1,73 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryDNSSECResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + insecure: str = FieldInfo(alias="INSECURE") + + invalid: str = FieldInfo(alias="INVALID") + + other: str = FieldInfo(alias="OTHER") + + secure: str = FieldInfo(alias="SECURE") + + +class SummaryDNSSECResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_ip_version_params.py b/src/cloudflare/types/radar/dns/summary_ip_version_params.py new file mode 100644 index 00000000000..95169ce78de --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_ip_version_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryIPVersionParams"] + + +class SummaryIPVersionParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_ip_version_response.py b/src/cloudflare/types/radar/dns/summary_ip_version_response.py new file mode 100644 index 00000000000..6286c80dc1d --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_ip_version_response.py @@ -0,0 +1,69 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryIPVersionResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + i_pv4: str = FieldInfo(alias="IPv4") + + i_pv6: str = FieldInfo(alias="IPv6") + + +class SummaryIPVersionResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_matching_answer_params.py b/src/cloudflare/types/radar/dns/summary_matching_answer_params.py new file mode 100644 index 00000000000..00e7e385ba3 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_matching_answer_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryMatchingAnswerParams"] + + +class SummaryMatchingAnswerParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_matching_answer_response.py b/src/cloudflare/types/radar/dns/summary_matching_answer_response.py new file mode 100644 index 00000000000..b232290ab60 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_matching_answer_response.py @@ -0,0 +1,69 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryMatchingAnswerResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + negative: str = FieldInfo(alias="NEGATIVE") + + positive: str = FieldInfo(alias="POSITIVE") + + +class SummaryMatchingAnswerResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_protocol_params.py b/src/cloudflare/types/radar/dns/summary_protocol_params.py new file mode 100644 index 00000000000..0fa4bc77b67 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_protocol_params.py @@ -0,0 +1,183 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryProtocolParams"] + + +class SummaryProtocolParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_protocol_response.py b/src/cloudflare/types/radar/dns/summary_protocol_response.py new file mode 100644 index 00000000000..b75c6a52eb9 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_protocol_response.py @@ -0,0 +1,73 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryProtocolResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + https: str = FieldInfo(alias="HTTPS") + + tcp: str = FieldInfo(alias="TCP") + + tls: str = FieldInfo(alias="TLS") + + udp: str = FieldInfo(alias="UDP") + + +class SummaryProtocolResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/summary_query_type_params.py b/src/cloudflare/types/radar/dns/summary_query_type_params.py new file mode 100644 index 00000000000..af6818f7de6 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_query_type_params.py @@ -0,0 +1,97 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryQueryTypeParams"] + + +class SummaryQueryTypeParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + limit_per_group: Annotated[int, PropertyInfo(alias="limitPerGroup")] + """ + Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + """ + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_query_type_response.py b/src/cloudflare/types/radar/dns/summary_query_type_response.py new file mode 100644 index 00000000000..87baa9cd63b --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_query_type_response.py @@ -0,0 +1,56 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["SummaryQueryTypeResponse", "Meta", "MetaDateRange", "MetaConfidenceInfo", "MetaConfidenceInfoAnnotation"] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class SummaryQueryTypeResponse(BaseModel): + meta: Meta + + summary_0: Dict[str, str] diff --git a/src/cloudflare/types/radar/dns/summary_response_code_params.py b/src/cloudflare/types/radar/dns/summary_response_code_params.py new file mode 100644 index 00000000000..058cd6523cc --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_response_code_params.py @@ -0,0 +1,168 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryResponseCodeParams"] + + +class SummaryResponseCodeParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + limit_per_group: Annotated[int, PropertyInfo(alias="limitPerGroup")] + """ + Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + """ + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_response_code_response.py b/src/cloudflare/types/radar/dns/summary_response_code_response.py new file mode 100644 index 00000000000..01764dfda55 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_response_code_response.py @@ -0,0 +1,56 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["SummaryResponseCodeResponse", "Meta", "MetaDateRange", "MetaConfidenceInfo", "MetaConfidenceInfoAnnotation"] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class SummaryResponseCodeResponse(BaseModel): + meta: Meta + + summary_0: Dict[str, str] diff --git a/src/cloudflare/types/radar/dns/summary_response_ttl_params.py b/src/cloudflare/types/radar/dns/summary_response_ttl_params.py new file mode 100644 index 00000000000..42a48bf3fed --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_response_ttl_params.py @@ -0,0 +1,186 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["SummaryResponseTTLParams"] + + +class SummaryResponseTTLParams(TypedDict, total=False): + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/summary_response_ttl_response.py b/src/cloudflare/types/radar/dns/summary_response_ttl_response.py new file mode 100644 index 00000000000..8c3259e1ec4 --- /dev/null +++ b/src/cloudflare/types/radar/dns/summary_response_ttl_response.py @@ -0,0 +1,79 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = [ + "SummaryResponseTTLResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Summary0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: str = FieldInfo(alias="lastUpdated") + + normalization: str + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Summary0(BaseModel): + gt_15m_lte_1h: str + + gt_1d_lte_1w: str + + gt_1h_lte_1d: str + + gt_1m_lte_5m: str + + gt_1w: str + + gt_5m_lte_15m: str + + lte_1m: str + + +class SummaryResponseTTLResponse(BaseModel): + meta: Meta + + summary_0: Summary0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_cache_hit_params.py b/src/cloudflare/types/radar/dns/timeseries_group_cache_hit_params.py new file mode 100644 index 00000000000..d7fadac76f6 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_cache_hit_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupCacheHitParams"] + + +class TimeseriesGroupCacheHitParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_cache_hit_response.py b/src/cloudflare/types/radar/dns/timeseries_group_cache_hit_response.py new file mode 100644 index 00000000000..97208f52613 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_cache_hit_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupCacheHitResponse", "Serie0"] + + +class Serie0(BaseModel): + negative: List[str] = FieldInfo(alias="NEGATIVE") + + positive: List[str] = FieldInfo(alias="POSITIVE") + + +class TimeseriesGroupCacheHitResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_dnssec_aware_params.py b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_aware_params.py new file mode 100644 index 00000000000..3fb3f7d737c --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_aware_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupDNSSECAwareParams"] + + +class TimeseriesGroupDNSSECAwareParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_dnssec_aware_response.py b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_aware_response.py new file mode 100644 index 00000000000..db3f76bd240 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_aware_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupDNSSECAwareResponse", "Serie0"] + + +class Serie0(BaseModel): + not_supported: List[str] = FieldInfo(alias="NOT_SUPPORTED") + + supported: List[str] = FieldInfo(alias="SUPPORTED") + + +class TimeseriesGroupDNSSECAwareResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_dnssec_e2e_params.py b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_e2e_params.py new file mode 100644 index 00000000000..86098545ae9 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_e2e_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupDNSSECE2EParams"] + + +class TimeseriesGroupDNSSECE2EParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_dnssec_e2e_response.py b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_e2e_response.py new file mode 100644 index 00000000000..7b324937876 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_e2e_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupDNSSECE2EResponse", "Serie0"] + + +class Serie0(BaseModel): + negative: List[str] = FieldInfo(alias="NEGATIVE") + + positive: List[str] = FieldInfo(alias="POSITIVE") + + +class TimeseriesGroupDNSSECE2EResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_dnssec_params.py b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_params.py new file mode 100644 index 00000000000..fadfd86d120 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupDNSSECParams"] + + +class TimeseriesGroupDNSSECParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_dnssec_response.py b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_response.py new file mode 100644 index 00000000000..d87e01cceef --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_dnssec_response.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupDNSSECResponse", "Serie0"] + + +class Serie0(BaseModel): + insecure: List[str] = FieldInfo(alias="INSECURE") + + invalid: List[str] = FieldInfo(alias="INVALID") + + other: List[str] = FieldInfo(alias="OTHER") + + secure: List[str] = FieldInfo(alias="SECURE") + + +class TimeseriesGroupDNSSECResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_ip_version_params.py b/src/cloudflare/types/radar/dns/timeseries_group_ip_version_params.py new file mode 100644 index 00000000000..ef21e49c067 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_ip_version_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupIPVersionParams"] + + +class TimeseriesGroupIPVersionParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_ip_version_response.py b/src/cloudflare/types/radar/dns/timeseries_group_ip_version_response.py new file mode 100644 index 00000000000..4e9128d1c2f --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_ip_version_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupIPVersionResponse", "Serie0"] + + +class Serie0(BaseModel): + i_pv4: List[str] = FieldInfo(alias="IPv4") + + i_pv6: List[str] = FieldInfo(alias="IPv6") + + +class TimeseriesGroupIPVersionResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_matching_answer_params.py b/src/cloudflare/types/radar/dns/timeseries_group_matching_answer_params.py new file mode 100644 index 00000000000..25ec610e725 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_matching_answer_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupMatchingAnswerParams"] + + +class TimeseriesGroupMatchingAnswerParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_matching_answer_response.py b/src/cloudflare/types/radar/dns/timeseries_group_matching_answer_response.py new file mode 100644 index 00000000000..c7ad80a20d4 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_matching_answer_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupMatchingAnswerResponse", "Serie0"] + + +class Serie0(BaseModel): + negative: List[str] = FieldInfo(alias="NEGATIVE") + + positive: List[str] = FieldInfo(alias="POSITIVE") + + +class TimeseriesGroupMatchingAnswerResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_protocol_params.py b/src/cloudflare/types/radar/dns/timeseries_group_protocol_params.py new file mode 100644 index 00000000000..c1fcccd265e --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_protocol_params.py @@ -0,0 +1,190 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupProtocolParams"] + + +class TimeseriesGroupProtocolParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_protocol_response.py b/src/cloudflare/types/radar/dns/timeseries_group_protocol_response.py new file mode 100644 index 00000000000..85baee000f5 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_protocol_response.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupProtocolResponse", "Serie0"] + + +class Serie0(BaseModel): + https: List[str] = FieldInfo(alias="HTTPS") + + tcp: List[str] = FieldInfo(alias="TCP") + + tls: List[str] = FieldInfo(alias="TLS") + + udp: List[str] = FieldInfo(alias="UDP") + + +class TimeseriesGroupProtocolResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_query_type_params.py b/src/cloudflare/types/radar/dns/timeseries_group_query_type_params.py new file mode 100644 index 00000000000..b636859dcc7 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_query_type_params.py @@ -0,0 +1,104 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupQueryTypeParams"] + + +class TimeseriesGroupQueryTypeParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + limit_per_group: Annotated[int, PropertyInfo(alias="limitPerGroup")] + """ + Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + """ + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_query_type_response.py b/src/cloudflare/types/radar/dns/timeseries_group_query_type_response.py new file mode 100644 index 00000000000..e63b0b06f8d --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_query_type_response.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupQueryTypeResponse", "Serie0"] + + +class Serie0(BaseModel): + a: List[str] = FieldInfo(alias="A") + + aaaa: List[str] = FieldInfo(alias="AAAA") + + https: List[str] = FieldInfo(alias="HTTPS") + + ns: List[str] = FieldInfo(alias="NS") + + ptr: List[str] = FieldInfo(alias="PTR") + + +class TimeseriesGroupQueryTypeResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_response_code_params.py b/src/cloudflare/types/radar/dns/timeseries_group_response_code_params.py new file mode 100644 index 00000000000..42c50e8fedc --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_response_code_params.py @@ -0,0 +1,175 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupResponseCodeParams"] + + +class TimeseriesGroupResponseCodeParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + limit_per_group: Annotated[int, PropertyInfo(alias="limitPerGroup")] + """ + Limits the number of objects per group to the top items within the specified + time range. If there are more items than the limit, the response will include + the count of items, with any remaining items grouped together under an "other" + category. + """ + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_response_code_response.py b/src/cloudflare/types/radar/dns/timeseries_group_response_code_response.py new file mode 100644 index 00000000000..7ddc6532192 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_response_code_response.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupResponseCodeResponse", "Serie0"] + + +class Serie0(BaseModel): + noerror: List[str] = FieldInfo(alias="NOERROR") + + notimp: List[str] = FieldInfo(alias="NOTIMP") + + nxdomain: List[str] = FieldInfo(alias="NXDOMAIN") + + refused: List[str] = FieldInfo(alias="REFUSED") + + servfail: List[str] = FieldInfo(alias="SERVFAIL") + + +class TimeseriesGroupResponseCodeResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns/timeseries_group_response_ttl_params.py b/src/cloudflare/types/radar/dns/timeseries_group_response_ttl_params.py new file mode 100644 index 00000000000..aecebf198ef --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_response_ttl_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["TimeseriesGroupResponseTTLParams"] + + +class TimeseriesGroupResponseTTLParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns/timeseries_group_response_ttl_response.py b/src/cloudflare/types/radar/dns/timeseries_group_response_ttl_response.py new file mode 100644 index 00000000000..2ba2fcea097 --- /dev/null +++ b/src/cloudflare/types/radar/dns/timeseries_group_response_ttl_response.py @@ -0,0 +1,29 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from ...._models import BaseModel + +__all__ = ["TimeseriesGroupResponseTTLResponse", "Serie0"] + + +class Serie0(BaseModel): + gt_15m_lte_1h: List[str] + + gt_1d_lte_1w: List[str] + + gt_1h_lte_1d: List[str] + + gt_1m_lte_5m: List[str] + + gt_1w: List[str] + + gt_5m_lte_15m: List[str] + + lte_1m: List[str] + + +class TimeseriesGroupResponseTTLResponse(BaseModel): + meta: object + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/dns_timeseries_params.py b/src/cloudflare/types/radar/dns_timeseries_params.py new file mode 100644 index 00000000000..17b32a92dab --- /dev/null +++ b/src/cloudflare/types/radar/dns_timeseries_params.py @@ -0,0 +1,193 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["DNSTimeseriesParams"] + + +class DNSTimeseriesParams(TypedDict, total=False): + agg_interval: Annotated[Literal["15m", "1h", "1d", "1w"], PropertyInfo(alias="aggInterval")] + """ + Aggregation interval results should be returned in (for example, in 15 minutes + or 1 hour intervals). Refer to + [Aggregation intervals](https://developers.cloudflare.com/radar/concepts/aggregation-intervals/). + """ + + asn: List[str] + """Comma-separated list of Autonomous System Numbers (ASNs). + + Prefix with `-` to exclude ASNs from results. For example, `-174, 3356` excludes + results from AS174, but includes results from AS3356. + """ + + continent: List[str] + """Comma-separated list of continents (alpha-2 continent codes). + + Prefix with `-` to exclude continents from results. For example, `-EU,NA` + excludes results from EU, but includes results from NA. + """ + + date_end: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateEnd", format="iso8601")] + """End of the date range (inclusive).""" + + date_range: Annotated[List[str], PropertyInfo(alias="dateRange")] + """Filters results by the specified date range. + + For example, use `7d` and `7dcontrol` to compare this week with the previous + week. Use this parameter or set specific start and end dates (`dateStart` and + `dateEnd` parameters). + """ + + date_start: Annotated[List[Union[str, datetime]], PropertyInfo(alias="dateStart", format="iso8601")] + """Start of the date range.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + location: List[str] + """Comma-separated list of locations (alpha-2 codes). + + Prefix with `-` to exclude locations from results. For example, `-US,PT` + excludes results from the US, but includes results from PT. + """ + + name: List[str] + """Array of names used to label the series in the response.""" + + nodata: bool + """Includes empty DNS responses (NODATA).""" + + protocol: Literal["UDP", "TCP", "HTTPS", "TLS"] + """Filters results by DNS transport protocol.""" + + query_type: Annotated[ + Optional[ + Literal[ + "A", + "AAAA", + "A6", + "AFSDB", + "ANY", + "APL", + "ATMA", + "AXFR", + "CAA", + "CDNSKEY", + "CDS", + "CERT", + "CNAME", + "CSYNC", + "DHCID", + "DLV", + "DNAME", + "DNSKEY", + "DOA", + "DS", + "EID", + "EUI48", + "EUI64", + "GPOS", + "GID", + "HINFO", + "HIP", + "HTTPS", + "IPSECKEY", + "ISDN", + "IXFR", + "KEY", + "KX", + "L32", + "L64", + "LOC", + "LP", + "MAILA", + "MAILB", + "MB", + "MD", + "MF", + "MG", + "MINFO", + "MR", + "MX", + "NAPTR", + "NB", + "NBSTAT", + "NID", + "NIMLOC", + "NINFO", + "NS", + "NSAP", + "NSEC", + "NSEC3", + "NSEC3PARAM", + "NULL", + "NXT", + "OPENPGPKEY", + "OPT", + "PTR", + "PX", + "RKEY", + "RP", + "RRSIG", + "RT", + "SIG", + "SINK", + "SMIMEA", + "SOA", + "SPF", + "SRV", + "SSHFP", + "SVCB", + "TA", + "TALINK", + "TKEY", + "TLSA", + "TSIG", + "TXT", + "UINFO", + "UID", + "UNSPEC", + "URI", + "WKS", + "X25", + "ZONEMD", + ] + ], + PropertyInfo(alias="queryType"), + ] + """Filters results by DNS query type.""" + + response_code: Annotated[ + Literal[ + "NOERROR", + "FORMERR", + "SERVFAIL", + "NXDOMAIN", + "NOTIMP", + "REFUSED", + "YXDOMAIN", + "YXRRSET", + "NXRRSET", + "NOTAUTH", + "NOTZONE", + "BADSIG", + "BADKEY", + "BADTIME", + "BADMODE", + "BADNAME", + "BADALG", + "BADTRUNC", + "BADCOOKIE", + ], + PropertyInfo(alias="responseCode"), + ] + """Filters results by DNS response code.""" + + tld: List[str] + """Filters results by country code top-level domain (ccTLD).""" diff --git a/src/cloudflare/types/radar/dns_timeseries_response.py b/src/cloudflare/types/radar/dns_timeseries_response.py new file mode 100644 index 00000000000..1d17716bd40 --- /dev/null +++ b/src/cloudflare/types/radar/dns_timeseries_response.py @@ -0,0 +1,69 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = [ + "DNSTimeseriesResponse", + "Meta", + "MetaDateRange", + "MetaConfidenceInfo", + "MetaConfidenceInfoAnnotation", + "Serie0", +] + + +class MetaDateRange(BaseModel): + end_time: datetime = FieldInfo(alias="endTime") + """Adjusted end of date range.""" + + start_time: datetime = FieldInfo(alias="startTime") + """Adjusted start of date range.""" + + +class MetaConfidenceInfoAnnotation(BaseModel): + data_source: str = FieldInfo(alias="dataSource") + + description: str + + event_type: str = FieldInfo(alias="eventType") + + is_instantaneous: bool = FieldInfo(alias="isInstantaneous") + + end_time: Optional[datetime] = FieldInfo(alias="endTime", default=None) + + linked_url: Optional[str] = FieldInfo(alias="linkedUrl", default=None) + + start_time: Optional[datetime] = FieldInfo(alias="startTime", default=None) + + +class MetaConfidenceInfo(BaseModel): + annotations: Optional[List[MetaConfidenceInfoAnnotation]] = None + + level: Optional[int] = None + + +class Meta(BaseModel): + agg_interval: str = FieldInfo(alias="aggInterval") + + date_range: List[MetaDateRange] = FieldInfo(alias="dateRange") + + last_updated: datetime = FieldInfo(alias="lastUpdated") + + confidence_info: Optional[MetaConfidenceInfo] = FieldInfo(alias="confidenceInfo", default=None) + + +class Serie0(BaseModel): + timestamps: List[datetime] + + values: List[str] + + +class DNSTimeseriesResponse(BaseModel): + meta: Meta + + serie_0: Serie0 diff --git a/src/cloudflare/types/radar/ranking/__init__.py b/src/cloudflare/types/radar/ranking/__init__.py index de03bec4377..def9d7d4fc0 100644 --- a/src/cloudflare/types/radar/ranking/__init__.py +++ b/src/cloudflare/types/radar/ranking/__init__.py @@ -6,6 +6,8 @@ from .domain_get_response import DomainGetResponse as DomainGetResponse from .internet_service_top_params import InternetServiceTopParams as InternetServiceTopParams from .internet_service_top_response import InternetServiceTopResponse as InternetServiceTopResponse +from .internet_service_categories_params import InternetServiceCategoriesParams as InternetServiceCategoriesParams +from .internet_service_categories_response import InternetServiceCategoriesResponse as InternetServiceCategoriesResponse from .internet_service_timeseries_groups_params import ( InternetServiceTimeseriesGroupsParams as InternetServiceTimeseriesGroupsParams, ) diff --git a/src/cloudflare/types/radar/ranking/internet_service_categories_params.py b/src/cloudflare/types/radar/ranking/internet_service_categories_params.py new file mode 100644 index 00000000000..bba30e09f5b --- /dev/null +++ b/src/cloudflare/types/radar/ranking/internet_service_categories_params.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import datetime +from typing import List, Union +from typing_extensions import Literal, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["InternetServiceCategoriesParams"] + + +class InternetServiceCategoriesParams(TypedDict, total=False): + date: Annotated[List[Union[str, datetime.date]], PropertyInfo(format="iso8601")] + """Array of dates to filter the ranking.""" + + format: Literal["JSON", "CSV"] + """Format in which results will be returned.""" + + limit: int + """Limits the number of objects returned in the response.""" + + name: List[str] + """Array of names used to label the series in the response.""" diff --git a/src/cloudflare/types/radar/ranking/internet_service_categories_response.py b/src/cloudflare/types/radar/ranking/internet_service_categories_response.py new file mode 100644 index 00000000000..60a0c7facc2 --- /dev/null +++ b/src/cloudflare/types/radar/ranking/internet_service_categories_response.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from ...._models import BaseModel + +__all__ = ["InternetServiceCategoriesResponse", "Categories0"] + + +class Categories0(BaseModel): + name: str + + +class InternetServiceCategoriesResponse(BaseModel): + categories_0: List[Categories0] diff --git a/tests/api_resources/radar/dns/test_summary.py b/tests/api_resources/radar/dns/test_summary.py new file mode 100644 index 00000000000..33f17227c95 --- /dev/null +++ b/tests/api_resources/radar/dns/test_summary.py @@ -0,0 +1,912 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from cloudflare import Cloudflare, AsyncCloudflare +from tests.utils import assert_matches_type +from cloudflare._utils import parse_datetime +from cloudflare.types.radar.dns import ( + SummaryDNSSECResponse, + SummaryCacheHitResponse, + SummaryProtocolResponse, + SummaryDNSSECE2EResponse, + SummaryIPVersionResponse, + SummaryQueryTypeResponse, + SummaryDNSSECAwareResponse, + SummaryResponseTTLResponse, + SummaryResponseCodeResponse, + SummaryMatchingAnswerResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestSummary: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_cache_hit(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.cache_hit() + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + @parametrize + def test_method_cache_hit_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.cache_hit( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_cache_hit(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.cache_hit() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_cache_hit(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.cache_hit() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_dnssec(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.dnssec() + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + @parametrize + def test_method_dnssec_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.dnssec( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_dnssec(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.dnssec() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_dnssec(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.dnssec() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_dnssec_aware(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.dnssec_aware() + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + @parametrize + def test_method_dnssec_aware_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.dnssec_aware( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_dnssec_aware(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.dnssec_aware() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_dnssec_aware(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.dnssec_aware() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_dnssec_e2e(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.dnssec_e2e() + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + @parametrize + def test_method_dnssec_e2e_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.dnssec_e2e( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_dnssec_e2e(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.dnssec_e2e() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_dnssec_e2e(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.dnssec_e2e() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_ip_version(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.ip_version() + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + @parametrize + def test_method_ip_version_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.ip_version( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_ip_version(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.ip_version() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_ip_version(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.ip_version() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_matching_answer(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.matching_answer() + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + @parametrize + def test_method_matching_answer_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.matching_answer( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_matching_answer(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.matching_answer() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_matching_answer(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.matching_answer() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_protocol(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.protocol() + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + @parametrize + def test_method_protocol_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.protocol( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_protocol(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.protocol() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_protocol(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.protocol() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_query_type(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.query_type() + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + @parametrize + def test_method_query_type_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.query_type( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_query_type(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.query_type() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_query_type(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.query_type() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_response_code(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.response_code() + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + @parametrize + def test_method_response_code_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.response_code( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + tld=["string"], + ) + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_response_code(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.response_code() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_response_code(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.response_code() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_response_ttl(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.response_ttl() + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + @parametrize + def test_method_response_ttl_with_all_params(self, client: Cloudflare) -> None: + summary = client.radar.dns.summary.response_ttl( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + @parametrize + def test_raw_response_response_ttl(self, client: Cloudflare) -> None: + response = client.radar.dns.summary.with_raw_response.response_ttl() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = response.parse() + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + @parametrize + def test_streaming_response_response_ttl(self, client: Cloudflare) -> None: + with client.radar.dns.summary.with_streaming_response.response_ttl() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = response.parse() + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncSummary: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_cache_hit(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.cache_hit() + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + @parametrize + async def test_method_cache_hit_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.cache_hit( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_cache_hit(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.cache_hit() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_cache_hit(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.cache_hit() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryCacheHitResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_dnssec(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.dnssec() + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + @parametrize + async def test_method_dnssec_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.dnssec( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_dnssec(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.dnssec() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_dnssec(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.dnssec() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryDNSSECResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_dnssec_aware(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.dnssec_aware() + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + @parametrize + async def test_method_dnssec_aware_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.dnssec_aware( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_dnssec_aware(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.dnssec_aware() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_dnssec_aware(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.dnssec_aware() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryDNSSECAwareResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_dnssec_e2e(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.dnssec_e2e() + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + @parametrize + async def test_method_dnssec_e2e_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.dnssec_e2e( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_dnssec_e2e(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.dnssec_e2e() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_dnssec_e2e(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.dnssec_e2e() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryDNSSECE2EResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_ip_version(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.ip_version() + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + @parametrize + async def test_method_ip_version_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.ip_version( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_ip_version(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.ip_version() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_ip_version(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.ip_version() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryIPVersionResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_matching_answer(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.matching_answer() + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + @parametrize + async def test_method_matching_answer_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.matching_answer( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_matching_answer(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.matching_answer() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_matching_answer(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.matching_answer() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryMatchingAnswerResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_protocol(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.protocol() + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + @parametrize + async def test_method_protocol_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.protocol( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_protocol(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.protocol() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_protocol(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.protocol() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryProtocolResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_query_type(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.query_type() + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + @parametrize + async def test_method_query_type_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.query_type( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_query_type(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.query_type() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_query_type(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.query_type() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryQueryTypeResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_response_code(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.response_code() + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + @parametrize + async def test_method_response_code_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.response_code( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + tld=["string"], + ) + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_response_code(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.response_code() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_response_code(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.response_code() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryResponseCodeResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_response_ttl(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.response_ttl() + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + @parametrize + async def test_method_response_ttl_with_all_params(self, async_client: AsyncCloudflare) -> None: + summary = await async_client.radar.dns.summary.response_ttl( + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + @parametrize + async def test_raw_response_response_ttl(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.summary.with_raw_response.response_ttl() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + summary = await response.parse() + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + @parametrize + async def test_streaming_response_response_ttl(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.summary.with_streaming_response.response_ttl() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + summary = await response.parse() + assert_matches_type(SummaryResponseTTLResponse, summary, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/radar/dns/test_timeseries_groups.py b/tests/api_resources/radar/dns/test_timeseries_groups.py new file mode 100644 index 00000000000..af583f6ddfa --- /dev/null +++ b/tests/api_resources/radar/dns/test_timeseries_groups.py @@ -0,0 +1,932 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from cloudflare import Cloudflare, AsyncCloudflare +from tests.utils import assert_matches_type +from cloudflare._utils import parse_datetime +from cloudflare.types.radar.dns import ( + TimeseriesGroupDNSSECResponse, + TimeseriesGroupCacheHitResponse, + TimeseriesGroupProtocolResponse, + TimeseriesGroupDNSSECE2EResponse, + TimeseriesGroupIPVersionResponse, + TimeseriesGroupQueryTypeResponse, + TimeseriesGroupDNSSECAwareResponse, + TimeseriesGroupResponseTTLResponse, + TimeseriesGroupResponseCodeResponse, + TimeseriesGroupMatchingAnswerResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestTimeseriesGroups: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_cache_hit(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.cache_hit() + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_cache_hit_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.cache_hit( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_cache_hit(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.cache_hit() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_cache_hit(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.cache_hit() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_dnssec(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.dnssec() + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_dnssec_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.dnssec( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_dnssec(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.dnssec() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_dnssec(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.dnssec() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_dnssec_aware(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.dnssec_aware() + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_dnssec_aware_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.dnssec_aware( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_dnssec_aware(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.dnssec_aware() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_dnssec_aware(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.dnssec_aware() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_dnssec_e2e(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.dnssec_e2e() + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_dnssec_e2e_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.dnssec_e2e( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_dnssec_e2e(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.dnssec_e2e() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_dnssec_e2e(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.dnssec_e2e() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_ip_version(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.ip_version() + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_ip_version_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.ip_version( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_ip_version(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.ip_version() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_ip_version(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.ip_version() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_matching_answer(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.matching_answer() + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_matching_answer_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.matching_answer( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_matching_answer(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.matching_answer() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_matching_answer(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.matching_answer() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_protocol(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.protocol() + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_protocol_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.protocol( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_protocol(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.protocol() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_protocol(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.protocol() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_query_type(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.query_type() + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_query_type_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.query_type( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_query_type(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.query_type() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_query_type(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.query_type() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_response_code(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.response_code() + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_response_code_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.response_code( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_response_code(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.response_code() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_response_code(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.response_code() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_response_ttl(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.response_ttl() + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + @parametrize + def test_method_response_ttl_with_all_params(self, client: Cloudflare) -> None: + timeseries_group = client.radar.dns.timeseries_groups.response_ttl( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + @parametrize + def test_raw_response_response_ttl(self, client: Cloudflare) -> None: + response = client.radar.dns.timeseries_groups.with_raw_response.response_ttl() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + @parametrize + def test_streaming_response_response_ttl(self, client: Cloudflare) -> None: + with client.radar.dns.timeseries_groups.with_streaming_response.response_ttl() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = response.parse() + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncTimeseriesGroups: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_cache_hit(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.cache_hit() + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_cache_hit_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.cache_hit( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_cache_hit(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.cache_hit() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_cache_hit(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.cache_hit() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupCacheHitResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_dnssec(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.dnssec() + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_dnssec_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.dnssec( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_dnssec(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.dnssec() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_dnssec(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.dnssec() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupDNSSECResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_dnssec_aware(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.dnssec_aware() + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_dnssec_aware_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.dnssec_aware( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_dnssec_aware(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.dnssec_aware() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_dnssec_aware(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.dnssec_aware() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupDNSSECAwareResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_dnssec_e2e(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.dnssec_e2e() + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_dnssec_e2e_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.dnssec_e2e( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_dnssec_e2e(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.dnssec_e2e() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_dnssec_e2e(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.dnssec_e2e() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupDNSSECE2EResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_ip_version(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.ip_version() + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_ip_version_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.ip_version( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_ip_version(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.ip_version() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_ip_version(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.ip_version() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupIPVersionResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_matching_answer(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.matching_answer() + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_matching_answer_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.matching_answer( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_matching_answer(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.matching_answer() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_matching_answer(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.matching_answer() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupMatchingAnswerResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_protocol(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.protocol() + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_protocol_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.protocol( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_protocol(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.protocol() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_protocol(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.protocol() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupProtocolResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_query_type(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.query_type() + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_query_type_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.query_type( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_query_type(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.query_type() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_query_type(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.query_type() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupQueryTypeResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_response_code(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.response_code() + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_response_code_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.response_code( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + limit_per_group=10, + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_response_code(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.response_code() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_response_code(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.response_code() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupResponseCodeResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_response_ttl(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.response_ttl() + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_method_response_ttl_with_all_params(self, async_client: AsyncCloudflare) -> None: + timeseries_group = await async_client.radar.dns.timeseries_groups.response_ttl( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_raw_response_response_ttl(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.timeseries_groups.with_raw_response.response_ttl() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + @parametrize + async def test_streaming_response_response_ttl(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.timeseries_groups.with_streaming_response.response_ttl() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + timeseries_group = await response.parse() + assert_matches_type(TimeseriesGroupResponseTTLResponse, timeseries_group, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/radar/ranking/test_internet_services.py b/tests/api_resources/radar/ranking/test_internet_services.py index c39961e86e9..77fbb715bb4 100644 --- a/tests/api_resources/radar/ranking/test_internet_services.py +++ b/tests/api_resources/radar/ranking/test_internet_services.py @@ -12,6 +12,7 @@ from cloudflare._utils import parse_date, parse_datetime from cloudflare.types.radar.ranking import ( InternetServiceTopResponse, + InternetServiceCategoriesResponse, InternetServiceTimeseriesGroupsResponse, ) @@ -21,6 +22,41 @@ class TestInternetServices: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + @parametrize + def test_method_categories(self, client: Cloudflare) -> None: + internet_service = client.radar.ranking.internet_services.categories() + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + @parametrize + def test_method_categories_with_all_params(self, client: Cloudflare) -> None: + internet_service = client.radar.ranking.internet_services.categories( + date=[parse_date("2019-12-27")], + format="JSON", + limit=5, + name=["main_series"], + ) + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + @parametrize + def test_raw_response_categories(self, client: Cloudflare) -> None: + response = client.radar.ranking.internet_services.with_raw_response.categories() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + internet_service = response.parse() + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + @parametrize + def test_streaming_response_categories(self, client: Cloudflare) -> None: + with client.radar.ranking.internet_services.with_streaming_response.categories() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + internet_service = response.parse() + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + assert cast(Any, response.is_closed) is True + @parametrize def test_method_timeseries_groups(self, client: Cloudflare) -> None: internet_service = client.radar.ranking.internet_services.timeseries_groups() @@ -99,6 +135,41 @@ def test_streaming_response_top(self, client: Cloudflare) -> None: class TestAsyncInternetServices: parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + @parametrize + async def test_method_categories(self, async_client: AsyncCloudflare) -> None: + internet_service = await async_client.radar.ranking.internet_services.categories() + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + @parametrize + async def test_method_categories_with_all_params(self, async_client: AsyncCloudflare) -> None: + internet_service = await async_client.radar.ranking.internet_services.categories( + date=[parse_date("2019-12-27")], + format="JSON", + limit=5, + name=["main_series"], + ) + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + @parametrize + async def test_raw_response_categories(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.ranking.internet_services.with_raw_response.categories() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + internet_service = await response.parse() + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + @parametrize + async def test_streaming_response_categories(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.ranking.internet_services.with_streaming_response.categories() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + internet_service = await response.parse() + assert_matches_type(InternetServiceCategoriesResponse, internet_service, path=["response"]) + + assert cast(Any, response.is_closed) is True + @parametrize async def test_method_timeseries_groups(self, async_client: AsyncCloudflare) -> None: internet_service = await async_client.radar.ranking.internet_services.timeseries_groups() diff --git a/tests/api_resources/radar/test_dns.py b/tests/api_resources/radar/test_dns.py new file mode 100644 index 00000000000..c7e4cb09635 --- /dev/null +++ b/tests/api_resources/radar/test_dns.py @@ -0,0 +1,113 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from cloudflare import Cloudflare, AsyncCloudflare +from tests.utils import assert_matches_type +from cloudflare._utils import parse_datetime +from cloudflare.types.radar import DNSTimeseriesResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestDNS: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_timeseries(self, client: Cloudflare) -> None: + dns = client.radar.dns.timeseries() + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + @parametrize + def test_method_timeseries_with_all_params(self, client: Cloudflare) -> None: + dns = client.radar.dns.timeseries( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + @parametrize + def test_raw_response_timeseries(self, client: Cloudflare) -> None: + response = client.radar.dns.with_raw_response.timeseries() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + dns = response.parse() + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + @parametrize + def test_streaming_response_timeseries(self, client: Cloudflare) -> None: + with client.radar.dns.with_streaming_response.timeseries() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + dns = response.parse() + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncDNS: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_timeseries(self, async_client: AsyncCloudflare) -> None: + dns = await async_client.radar.dns.timeseries() + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + @parametrize + async def test_method_timeseries_with_all_params(self, async_client: AsyncCloudflare) -> None: + dns = await async_client.radar.dns.timeseries( + agg_interval="15m", + asn=["string"], + continent=["string"], + date_end=[parse_datetime("2019-12-27T18:11:19.117Z")], + date_range=["7d"], + date_start=[parse_datetime("2019-12-27T18:11:19.117Z")], + format="JSON", + location=["string"], + name=["main_series"], + nodata=True, + protocol="UDP", + query_type="A", + response_code="NOERROR", + tld=["string"], + ) + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + @parametrize + async def test_raw_response_timeseries(self, async_client: AsyncCloudflare) -> None: + response = await async_client.radar.dns.with_raw_response.timeseries() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + dns = await response.parse() + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + @parametrize + async def test_streaming_response_timeseries(self, async_client: AsyncCloudflare) -> None: + async with async_client.radar.dns.with_streaming_response.timeseries() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + dns = await response.parse() + assert_matches_type(DNSTimeseriesResponse, dns, path=["response"]) + + assert cast(Any, response.is_closed) is True