#![cfg(feature = "cloudflare_radar")]
#![allow(clippy::too_many_arguments, clippy::type_complexity)]
#![allow(
clippy::missing_errors_doc,
clippy::doc_markdown,
clippy::useless_format
)]
#![allow(unused_imports)]
use foundation_macros::JsonHash;
use foundation_netio::shared::client::http_client::HttpClient;
use foundation_netio::{DynNetClient, PreparedRequestBuilder};
use serde::{Deserialize, Serialize};
use super::shared::ApiResponse;
pub type RadarGetAnnotationsOutagesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetAnnotationsOutagesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsOutagesResponseResult {
pub annotations: Vec<RadarGetAnnotationsOutagesResponseResultAnnotationsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsOutagesResponseResultAnnotationsItem {
pub asns: Vec<i64>,
#[serde(rename = "asnsDetails")]
pub asns_details: Vec<RadarGetAnnotationsOutagesResponseResultAnnotationsItemAsnsDetailsItem>,
#[serde(rename = "dataSource")]
pub data_source: String,
pub description: Option<String>,
#[serde(rename = "endDate")]
pub end_date: Option<String>,
#[serde(rename = "eventType")]
pub event_type: String,
pub id: String,
#[serde(rename = "linkedUrl")]
pub linked_url: Option<String>,
pub locations: Vec<String>,
#[serde(rename = "locationsDetails")]
pub locations_details:
Vec<RadarGetAnnotationsOutagesResponseResultAnnotationsItemLocationsDetailsItem>,
pub origins: Vec<String>,
#[serde(rename = "originsDetails")]
pub origins_details:
Vec<RadarGetAnnotationsOutagesResponseResultAnnotationsItemOriginsDetailsItem>,
pub outage: RadarGetAnnotationsOutagesResponseResultAnnotationsItemOutage,
pub scope: Option<String>,
#[serde(rename = "startDate")]
pub start_date: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsOutagesResponseResultAnnotationsItemAsnsDetailsItem {
pub asn: String,
pub locations:
Option<RadarGetAnnotationsOutagesResponseResultAnnotationsItemAsnsDetailsItemLocations>,
pub name: String,
}
pub type RadarGetAnnotationsOutagesResponseResultAnnotationsItemAsnsDetailsItemLocations =
super::shared::CodeNameObject;
pub type RadarGetAnnotationsOutagesResponseResultAnnotationsItemLocationsDetailsItem =
super::shared::CodeNameObject;
pub type RadarGetAnnotationsOutagesResponseResultAnnotationsItemOriginsDetailsItem =
super::shared::NameOriginObject;
pub type RadarGetAnnotationsOutagesResponseResultAnnotationsItemOutage =
super::shared::OutageCauseOutageTypeObject;
pub type RadarGetAnnotationsOutagesTopResponse =
super::shared::ApiEnvelopeSuccess<RadarGetAnnotationsOutagesTopResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsOutagesTopResponseResult {
pub annotations: Vec<RadarGetAnnotationsOutagesTopResponseResultAnnotationsItem>,
}
pub type RadarGetAnnotationsOutagesTopResponseResultAnnotationsItem =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetAnnotationsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetAnnotationsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsResponseResult {
pub annotations: Vec<RadarGetAnnotationsResponseResultAnnotationsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsResponseResultAnnotationsItem {
pub asns: Vec<i64>,
#[serde(rename = "asnsDetails")]
pub asns_details: Vec<RadarGetAnnotationsResponseResultAnnotationsItemAsnsDetailsItem>,
#[serde(rename = "dataSource")]
pub data_source: String,
pub description: Option<String>,
#[serde(rename = "endDate")]
pub end_date: Option<String>,
#[serde(rename = "eventType")]
pub event_type: String,
pub id: String,
#[serde(rename = "linkedUrl")]
pub linked_url: Option<String>,
pub locations: Vec<String>,
#[serde(rename = "locationsDetails")]
pub locations_details:
Vec<RadarGetAnnotationsResponseResultAnnotationsItemLocationsDetailsItem>,
pub origins: Vec<String>,
#[serde(rename = "originsDetails")]
pub origins_details: Vec<RadarGetAnnotationsResponseResultAnnotationsItemOriginsDetailsItem>,
pub outage: RadarGetAnnotationsResponseResultAnnotationsItemOutage,
pub scope: Option<String>,
#[serde(rename = "startDate")]
pub start_date: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAnnotationsResponseResultAnnotationsItemAsnsDetailsItem {
pub asn: String,
pub locations: Option<RadarGetAnnotationsResponseResultAnnotationsItemAsnsDetailsItemLocations>,
pub name: String,
}
pub type RadarGetAnnotationsResponseResultAnnotationsItemAsnsDetailsItemLocations =
super::shared::CodeNameObject;
pub type RadarGetAnnotationsResponseResultAnnotationsItemLocationsDetailsItem =
super::shared::CodeNameObject;
pub type RadarGetAnnotationsResponseResultAnnotationsItemOriginsDetailsItem =
super::shared::NameOriginObject;
pub type RadarGetAnnotationsResponseResultAnnotationsItemOutage =
super::shared::OutageCauseOutageTypeObject;
pub type RadarGetAsnsAsSetResponse =
super::shared::ApiEnvelopeSuccess<RadarGetAsnsAsSetResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAsnsAsSetResponseResult {
pub as_sets: Vec<RadarGetAsnsAsSetResponseResultAsSetsItem>,
pub paths: Vec<Vec<String>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAsnsAsSetResponseResultAsSetsItem {
pub as_members_count: i64,
pub as_set_members_count: i64,
pub as_set_upstreams_count: i64,
pub asn_cone_size: i64,
pub hierarchical_asn: Option<i64>,
pub inferred_asn: Option<i64>,
pub irr_sources: Vec<String>,
pub name: String,
pub peeringdb_asn: Option<i64>,
}
pub type RadarGetAsnsRelResponse = super::shared::ApiEnvelopeSuccess<RadarGetAsnsRelResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAsnsRelResponseResult {
pub meta: RadarGetAsnsRelResponseResultMeta,
pub rels: Vec<RadarGetAsnsRelResponseResultRelsItem>,
}
pub type RadarGetAsnsRelResponseResultMeta = super::shared::DataTimeQueryTimeTotalPeersObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetAsnsRelResponseResultRelsItem {
pub asn1: i64,
pub asn1_country: String,
pub asn1_name: String,
pub asn2: i64,
pub asn2_country: String,
pub asn2_name: String,
pub rel: String,
}
pub type RadarGetCertificateAuthoritiesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCertificateAuthoritiesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateAuthoritiesResponseResult {
#[serde(rename = "certificateAuthorities")]
pub certificate_authorities:
Vec<RadarGetCertificateAuthoritiesResponseResultCertificateAuthoritiesItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateAuthoritiesResponseResultCertificateAuthoritiesItem {
#[serde(rename = "certificateRecordType")]
pub certificate_record_type: String,
pub country: String,
#[serde(rename = "countryName")]
pub country_name: String,
pub name: String,
pub owner: String,
#[serde(rename = "parentName")]
pub parent_name: String,
#[serde(rename = "parentSha256Fingerprint")]
pub parent_sha256_fingerprint: String,
#[serde(rename = "revocationStatus")]
pub revocation_status: String,
#[serde(rename = "sha256Fingerprint")]
pub sha256_fingerprint: String,
}
pub type RadarGetCertificateAuthorityDetailsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCertificateAuthorityDetailsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateAuthorityDetailsResponseResult {
#[serde(rename = "certificateAuthority")]
pub certificate_authority:
RadarGetCertificateAuthorityDetailsResponseResultCertificateAuthority,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateAuthorityDetailsResponseResultCertificateAuthority {
#[serde(rename = "appleStatus")]
pub apple_status: String,
#[serde(rename = "authorityKeyIdentifier")]
pub authority_key_identifier: String,
#[serde(rename = "certificateRecordType")]
pub certificate_record_type: String,
#[serde(rename = "chromeStatus")]
pub chrome_status: String,
pub country: String,
#[serde(rename = "countryName")]
pub country_name: String,
#[serde(rename = "microsoftStatus")]
pub microsoft_status: String,
#[serde(rename = "mozillaStatus")]
pub mozilla_status: String,
pub name: String,
pub owner: String,
#[serde(rename = "parentName")]
pub parent_name: String,
#[serde(rename = "parentSha256Fingerprint")]
pub parent_sha256_fingerprint: String,
pub related:
Vec<RadarGetCertificateAuthorityDetailsResponseResultCertificateAuthorityRelatedItem>,
#[serde(rename = "revocationStatus")]
pub revocation_status: String,
#[serde(rename = "sha256Fingerprint")]
pub sha256_fingerprint: String,
#[serde(rename = "subjectKeyIdentifier")]
pub subject_key_identifier: String,
#[serde(rename = "validFrom")]
pub valid_from: String,
#[serde(rename = "validTo")]
pub valid_to: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateAuthorityDetailsResponseResultCertificateAuthorityRelatedItem {
#[serde(rename = "certificateRecordType")]
pub certificate_record_type: String,
pub name: String,
#[serde(rename = "revocationStatus")]
pub revocation_status: String,
#[serde(rename = "sha256Fingerprint")]
pub sha256_fingerprint: String,
}
pub type RadarGetCertificateLogDetailsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCertificateLogDetailsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogDetailsResponseResult {
#[serde(rename = "certificateLog")]
pub certificate_log: RadarGetCertificateLogDetailsResponseResultCertificateLog,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogDetailsResponseResultCertificateLog {
pub api: String,
#[serde(rename = "avgThroughput")]
pub avg_throughput: f64,
pub description: String,
#[serde(rename = "endExclusive")]
pub end_exclusive: String,
#[serde(rename = "lastUpdate")]
pub last_update: String,
pub operator: String,
pub performance: Option<RadarGetCertificateLogDetailsResponseResultCertificateLogPerformance>,
pub related: Vec<RadarGetCertificateLogDetailsResponseResultCertificateLogRelatedItem>,
pub slug: String,
#[serde(rename = "startInclusive")]
pub start_inclusive: String,
pub state: String,
#[serde(rename = "stateTimestamp")]
pub state_timestamp: String,
#[serde(rename = "submittableCertCount")]
pub submittable_cert_count: Option<String>,
#[serde(rename = "submittedCertCount")]
pub submitted_cert_count: Option<String>,
pub url: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogDetailsResponseResultCertificateLogPerformance {
pub endpoints:
Vec<RadarGetCertificateLogDetailsResponseResultCertificateLogPerformanceEndpointsItem>,
#[serde(rename = "responseTime")]
pub response_time: f64,
pub uptime: f64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogDetailsResponseResultCertificateLogPerformanceEndpointsItem {
pub endpoint: String,
#[serde(rename = "responseTime")]
pub response_time: f64,
pub uptime: f64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogDetailsResponseResultCertificateLogRelatedItem {
pub description: String,
#[serde(rename = "endExclusive")]
pub end_exclusive: String,
pub slug: String,
#[serde(rename = "startInclusive")]
pub start_inclusive: String,
pub state: String,
}
pub type RadarGetCertificateLogsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCertificateLogsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogsResponseResult {
#[serde(rename = "certificateLogs")]
pub certificate_logs: Vec<RadarGetCertificateLogsResponseResultCertificateLogsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCertificateLogsResponseResultCertificateLogsItem {
pub api: String,
pub description: String,
#[serde(rename = "endExclusive")]
pub end_exclusive: String,
pub operator: String,
pub slug: String,
#[serde(rename = "startInclusive")]
pub start_inclusive: String,
pub state: String,
#[serde(rename = "stateTimestamp")]
pub state_timestamp: String,
pub url: String,
}
pub type RadarGetCtSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCtSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtSummaryResponseResult {
pub meta: RadarGetCtSummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetCtSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetCtSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetCtSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtSummaryResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetCtSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetCtSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetCtSummaryResponseResultMetaDateRangeItem = super::shared::EndTimeStartTimeObject;
pub type RadarGetCtSummaryResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetCtTimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCtTimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtTimeseriesGroupResponseResult {
pub meta: RadarGetCtTimeseriesGroupResponseResultMeta,
pub serie_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtTimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetCtTimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetCtTimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetCtTimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtTimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetCtTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetCtTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetCtTimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetCtTimeseriesGroupResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetCtTimeseriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetCtTimeseriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtTimeseriesResponseResult {
pub meta: RadarGetCtTimeseriesResponseResultMeta,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtTimeseriesResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetCtTimeseriesResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetCtTimeseriesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetCtTimeseriesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetCtTimeseriesResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetCtTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetCtTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetCtTimeseriesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetCtTimeseriesResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetDnsAs112SummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112SummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112SummaryResponseResult {
pub meta: RadarGetDnsAs112SummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112SummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetDnsAs112SummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112SummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112SummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112SummaryResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetDnsAs112SummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112SummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112SummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112SummaryResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetDnsAs112TimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112TimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesGroupResponseResult {
pub meta: RadarGetDnsAs112TimeseriesGroupResponseResultMeta,
pub serie_0: RadarGetDnsAs112TimeseriesGroupResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetDnsAs112TimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112TimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112TimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetDnsAs112TimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112TimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112TimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112TimeseriesGroupResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetDnsAs112TimeseriesGroupResponseResultSerie0 = super::shared::TimestampsObject;
pub type RadarGetDnsAs112TimeseriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112TimeseriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesResponseResult {
pub meta: RadarGetDnsAs112TimeseriesResponseResultMeta,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetDnsAs112TimeseriesResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112TimeseriesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112TimeseriesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetDnsAs112TimeseriesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112TimeseriesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112TimeseriesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112TimeseriesResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetDnsAs112TopLocationsByDnssecResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112TopLocationsByDnssecResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByDnssecResponseResult {
pub meta: RadarGetDnsAs112TopLocationsByDnssecResponseResultMeta,
pub top_0: Vec<RadarGetDnsAs112TopLocationsByDnssecResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByDnssecResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112TopLocationsByDnssecResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetDnsAs112TopLocationsByDnssecResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetDnsAs112TopLocationsByEdnsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112TopLocationsByEdnsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByEdnsResponseResult {
pub meta: RadarGetDnsAs112TopLocationsByEdnsResponseResultMeta,
pub top_0: Vec<RadarGetDnsAs112TopLocationsByEdnsResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByEdnsResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112TopLocationsByEdnsResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetDnsAs112TopLocationsByEdnsResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetDnsAs112TopLocationsByIpVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112TopLocationsByIpVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByIpVersionResponseResult {
pub meta: RadarGetDnsAs112TopLocationsByIpVersionResponseResultMeta,
pub top_0: Vec<RadarGetDnsAs112TopLocationsByIpVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByIpVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112TopLocationsByIpVersionResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetDnsAs112TopLocationsByIpVersionResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetDnsAs112TopLocationsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetDnsAs112TopLocationsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsResponseResult {
pub meta: RadarGetDnsAs112TopLocationsResponseResultMeta,
pub top_0: Vec<RadarGetDnsAs112TopLocationsResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetDnsAs112TopLocationsResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetDnsAs112TopLocationsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetDnsAs112TopLocationsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetDnsAs112TopLocationsResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetDnsAs112TopLocationsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetDnsAs112TopLocationsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetDnsAs112TopLocationsResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetDnsAs112TopLocationsResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetEntitiesAsnByIdResponse =
super::shared::ApiEnvelopeSuccess<RadarGetEntitiesAsnByIdResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnByIdResponseResult {
pub asn: RadarGetEntitiesAsnByIdResponseResultAsn,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnByIdResponseResultAsn {
pub aka: Option<String>,
pub asn: i64,
#[serde(rename = "confidenceLevel")]
pub confidence_level: i64,
pub country: String,
#[serde(rename = "countryName")]
pub country_name: String,
#[serde(rename = "estimatedUsers")]
pub estimated_users: RadarGetEntitiesAsnByIdResponseResultAsnEstimatedUsers,
pub name: String,
#[serde(rename = "orgName")]
pub org_name: String,
pub related: Vec<RadarGetEntitiesAsnByIdResponseResultAsnRelatedItem>,
pub source: String,
pub website: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnByIdResponseResultAsnEstimatedUsers {
#[serde(rename = "estimatedUsers")]
pub estimated_users: Option<i64>,
pub locations: Vec<RadarGetEntitiesAsnByIdResponseResultAsnEstimatedUsersLocationsItem>,
}
pub type RadarGetEntitiesAsnByIdResponseResultAsnEstimatedUsersLocationsItem =
super::shared::EstimatedUsersLocationAlpha2LocationNameObject;
pub type RadarGetEntitiesAsnByIdResponseResultAsnRelatedItem =
super::shared::RadarGetEntitiesAsnByIdResponseResultAsnRelatedItemShape;
pub type RadarGetEntitiesAsnByIpResponse =
super::shared::ApiEnvelopeSuccess<RadarGetEntitiesAsnByIpResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnByIpResponseResult {
pub asn: RadarGetEntitiesAsnByIpResponseResultAsn,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnByIpResponseResultAsn {
pub aka: Option<String>,
pub asn: i64,
pub country: String,
#[serde(rename = "countryName")]
pub country_name: String,
#[serde(rename = "estimatedUsers")]
pub estimated_users: RadarGetEntitiesAsnByIpResponseResultAsnEstimatedUsers,
pub name: String,
#[serde(rename = "orgName")]
pub org_name: String,
pub related: Vec<RadarGetEntitiesAsnByIpResponseResultAsnRelatedItem>,
pub source: String,
pub website: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnByIpResponseResultAsnEstimatedUsers {
#[serde(rename = "estimatedUsers")]
pub estimated_users: Option<i64>,
pub locations: Vec<RadarGetEntitiesAsnByIpResponseResultAsnEstimatedUsersLocationsItem>,
}
pub type RadarGetEntitiesAsnByIpResponseResultAsnEstimatedUsersLocationsItem =
super::shared::EstimatedUsersLocationAlpha2LocationNameObject;
pub type RadarGetEntitiesAsnByIpResponseResultAsnRelatedItem =
super::shared::RadarGetEntitiesAsnByIdResponseResultAsnRelatedItemShape;
pub type RadarGetEntitiesAsnListResponse =
super::shared::ApiEnvelopeSuccess<RadarGetEntitiesAsnListResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnListResponseResult {
pub asns: Vec<RadarGetEntitiesAsnListResponseResultAsnsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesAsnListResponseResultAsnsItem {
pub aka: Option<String>,
pub asn: i64,
pub country: String,
#[serde(rename = "countryName")]
pub country_name: String,
pub name: String,
#[serde(rename = "orgName")]
pub org_name: Option<String>,
pub website: Option<String>,
}
pub type RadarGetEntitiesIpResponse =
super::shared::ApiEnvelopeSuccess<RadarGetEntitiesIpResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesIpResponseResult {
pub ip: RadarGetEntitiesIpResponseResultIp,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesIpResponseResultIp {
pub asn: String,
#[serde(rename = "asnLocation")]
pub asn_location: String,
#[serde(rename = "asnName")]
pub asn_name: String,
#[serde(rename = "asnOrgName")]
pub asn_org_name: String,
pub ip: String,
#[serde(rename = "ipVersion")]
pub ip_version: String,
pub location: String,
#[serde(rename = "locationName")]
pub location_name: String,
}
pub type RadarGetEntitiesLocationByAlpha2Response =
super::shared::ApiEnvelopeSuccess<RadarGetEntitiesLocationByAlpha2ResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesLocationByAlpha2ResponseResult {
pub location: RadarGetEntitiesLocationByAlpha2ResponseResultLocation,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesLocationByAlpha2ResponseResultLocation {
pub alpha2: String,
#[serde(rename = "confidenceLevel")]
pub confidence_level: i64,
pub continent: String,
pub latitude: String,
pub longitude: String,
pub name: String,
pub region: String,
pub subregion: String,
}
pub type RadarGetEntitiesLocationsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetEntitiesLocationsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesLocationsResponseResult {
pub locations: Vec<RadarGetEntitiesLocationsResponseResultLocationsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetEntitiesLocationsResponseResultLocationsItem {
pub alpha2: String,
pub continent: String,
pub latitude: String,
pub longitude: String,
pub name: String,
pub region: String,
pub subregion: String,
}
pub type RadarGetGeolocationDetailsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetGeolocationDetailsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetGeolocationDetailsResponseResult {
pub geolocation: RadarGetGeolocationDetailsResponseResultGeolocation,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetGeolocationDetailsResponseResultGeolocation {
pub code: Option<String>,
#[serde(rename = "geoId")]
pub geo_id: String,
pub latitude: String,
pub locale: Option<String>,
pub longitude: String,
pub name: String,
pub parent: RadarGetGeolocationDetailsResponseResultGeolocationParent,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetGeolocationDetailsResponseResultGeolocationParent {
pub code: Option<String>,
#[serde(rename = "geoId")]
pub geo_id: String,
pub latitude: String,
pub locale: Option<String>,
pub longitude: String,
pub name: String,
pub parent: RadarGetGeolocationDetailsResponseResultGeolocationParentParent,
#[serde(rename = "type")]
pub r#type: String,
}
pub type RadarGetGeolocationDetailsResponseResultGeolocationParentParent =
super::shared::RadarGetGeolocationDetailsResponseResultGeolocationParentParentShape;
pub type RadarGetGeolocationsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetGeolocationsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetGeolocationsResponseResult {
pub geolocations: Vec<RadarGetGeolocationsResponseResultGeolocationsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetGeolocationsResponseResultGeolocationsItem {
pub code: Option<String>,
#[serde(rename = "geoId")]
pub geo_id: String,
pub latitude: String,
pub locale: Option<String>,
pub longitude: String,
pub name: String,
pub parent: RadarGetGeolocationsResponseResultGeolocationsItemParent,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetGeolocationsResponseResultGeolocationsItemParent {
pub code: Option<String>,
#[serde(rename = "geoId")]
pub geo_id: String,
pub latitude: String,
pub locale: Option<String>,
pub longitude: String,
pub name: String,
pub parent: RadarGetGeolocationsResponseResultGeolocationsItemParentParent,
#[serde(rename = "type")]
pub r#type: String,
}
pub type RadarGetGeolocationsResponseResultGeolocationsItemParentParent =
super::shared::RadarGetGeolocationDetailsResponseResultGeolocationParentParentShape;
pub type RadarGetHttpSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpSummaryResponseResult {
pub meta: RadarGetHttpSummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetHttpSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpSummaryResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetHttpSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpSummaryResponseResultMetaDateRangeItem = super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpSummaryResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetHttpTimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTimeseriesGroupResponseResult {
pub meta: RadarGetHttpTimeseriesGroupResponseResultMeta,
pub serie_0: RadarGetHttpTimeseriesGroupResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetHttpTimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTimeseriesGroupResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetHttpTimeseriesGroupResponseResultSerie0 = super::shared::TimestampsObject;
pub type RadarGetHttpTimeseriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTimeseriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTimeseriesResponseResult {
pub meta: RadarGetHttpTimeseriesResponseResultMeta,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTimeseriesResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetHttpTimeseriesResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTimeseriesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTimeseriesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTimeseriesResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetHttpTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTimeseriesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTimeseriesResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByBrowserFamilyResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByBrowserFamilyResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByBrowserFamilyResponseResult {
pub meta: RadarGetHttpTopAsesByBrowserFamilyResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByBrowserFamilyResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByBrowserFamilyResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByBrowserFamilyResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByBrowserFamilyResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByDeviceTypeResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByDeviceTypeResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByDeviceTypeResponseResult {
pub meta: RadarGetHttpTopAsesByDeviceTypeResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByDeviceTypeResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByDeviceTypeResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByDeviceTypeResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByDeviceTypeResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByDeviceTypeResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByDeviceTypeResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByDeviceTypeResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByDeviceTypeResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByDeviceTypeResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByDeviceTypeResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByDeviceTypeResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByHttpProtocolResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByHttpProtocolResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpProtocolResponseResult {
pub meta: RadarGetHttpTopAsesByHttpProtocolResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByHttpProtocolResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpProtocolResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByHttpProtocolResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByHttpProtocolResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByHttpProtocolResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpProtocolResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByHttpProtocolResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByHttpProtocolResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByHttpProtocolResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByHttpProtocolResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByHttpProtocolResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByHttpRequestsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByHttpRequestsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpRequestsResponseResult {
pub meta: RadarGetHttpTopAsesByHttpRequestsResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByHttpRequestsResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpRequestsResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByHttpRequestsResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByHttpRequestsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByHttpRequestsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpRequestsResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByHttpRequestsResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByHttpRequestsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByHttpRequestsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByHttpRequestsResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByHttpRequestsResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByHttpVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByHttpVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpVersionResponseResult {
pub meta: RadarGetHttpTopAsesByHttpVersionResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByHttpVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByHttpVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByHttpVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByHttpVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByHttpVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByHttpVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByHttpVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByHttpVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByHttpVersionResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByHttpVersionResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByIpVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByIpVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByIpVersionResponseResult {
pub meta: RadarGetHttpTopAsesByIpVersionResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByIpVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByIpVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByIpVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByIpVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByIpVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByIpVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByIpVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByIpVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByIpVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByIpVersionResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByIpVersionResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByOperatingSystemResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByOperatingSystemResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByOperatingSystemResponseResult {
pub meta: RadarGetHttpTopAsesByOperatingSystemResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByOperatingSystemResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByOperatingSystemResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopAsesByOperatingSystemResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByOperatingSystemResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByOperatingSystemResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByOperatingSystemResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByOperatingSystemResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByOperatingSystemResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByOperatingSystemResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByOperatingSystemResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByOperatingSystemResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopAsesByTlsVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopAsesByTlsVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByTlsVersionResponseResult {
pub meta: RadarGetHttpTopAsesByTlsVersionResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopAsesByTlsVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByTlsVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetHttpTopAsesByTlsVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopAsesByTlsVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopAsesByTlsVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopAsesByTlsVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopAsesByTlsVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopAsesByTlsVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopAsesByTlsVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopAsesByTlsVersionResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopAsesByTlsVersionResponseResultTop0Item =
super::shared::ClientAsnClientAsNameValueObject;
pub type RadarGetHttpTopLocationsByBrowserFamilyResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByBrowserFamilyResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByBrowserFamilyResponseResult {
pub meta: RadarGetHttpTopLocationsByBrowserFamilyResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByBrowserFamilyResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByBrowserFamilyResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByBrowserFamilyResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByBrowserFamilyResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByDeviceTypeResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByDeviceTypeResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByDeviceTypeResponseResult {
pub meta: RadarGetHttpTopLocationsByDeviceTypeResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByDeviceTypeResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByDeviceTypeResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByDeviceTypeResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByDeviceTypeResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByHttpProtocolResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByHttpProtocolResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpProtocolResponseResult {
pub meta: RadarGetHttpTopLocationsByHttpProtocolResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByHttpProtocolResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpProtocolResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByHttpProtocolResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByHttpProtocolResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByHttpRequestsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByHttpRequestsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpRequestsResponseResult {
pub meta: RadarGetHttpTopLocationsByHttpRequestsResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByHttpRequestsResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpRequestsResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByHttpRequestsResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByHttpRequestsResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByHttpVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByHttpVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpVersionResponseResult {
pub meta: RadarGetHttpTopLocationsByHttpVersionResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByHttpVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByHttpVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByHttpVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByHttpVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByHttpVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByHttpVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByHttpVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByHttpVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByHttpVersionResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByHttpVersionResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByIpVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByIpVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByIpVersionResponseResult {
pub meta: RadarGetHttpTopLocationsByIpVersionResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByIpVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByIpVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByIpVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByIpVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByIpVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByIpVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByIpVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByIpVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByIpVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByIpVersionResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByIpVersionResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByOperatingSystemResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByOperatingSystemResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByOperatingSystemResponseResult {
pub meta: RadarGetHttpTopLocationsByOperatingSystemResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByOperatingSystemResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByOperatingSystemResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaConfidenceInfo {
pub annotations: Vec<
RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaConfidenceInfoAnnotationsItem,
>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByOperatingSystemResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByOperatingSystemResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetHttpTopLocationsByTlsVersionResponse =
super::shared::ApiEnvelopeSuccess<RadarGetHttpTopLocationsByTlsVersionResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByTlsVersionResponseResult {
pub meta: RadarGetHttpTopLocationsByTlsVersionResponseResultMeta,
pub top_0: Vec<RadarGetHttpTopLocationsByTlsVersionResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByTlsVersionResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info:
Option<RadarGetHttpTopLocationsByTlsVersionResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetHttpTopLocationsByTlsVersionResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetHttpTopLocationsByTlsVersionResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetHttpTopLocationsByTlsVersionResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetHttpTopLocationsByTlsVersionResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetHttpTopLocationsByTlsVersionResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetHttpTopLocationsByTlsVersionResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetHttpTopLocationsByTlsVersionResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetHttpTopLocationsByTlsVersionResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetLeakedCredentialChecksSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetLeakedCredentialChecksSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksSummaryResponseResult {
pub meta: RadarGetLeakedCredentialChecksSummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetLeakedCredentialChecksSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetLeakedCredentialChecksSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetLeakedCredentialChecksSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksSummaryResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetLeakedCredentialChecksSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetLeakedCredentialChecksSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetLeakedCredentialChecksSummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetLeakedCredentialChecksSummaryResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetLeakedCredentialChecksTimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetLeakedCredentialChecksTimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksTimeseriesGroupResponseResult {
pub meta: RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMeta,
pub serie_0: RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info:
RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range:
Vec<RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetLeakedCredentialChecksTimeseriesGroupResponseResultSerie0 =
super::shared::TimestampsObject;
pub type RadarGetNetflowsSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetNetflowsSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsSummaryResponseResult {
pub meta: RadarGetNetflowsSummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetNetflowsSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetNetflowsSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetNetflowsSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsSummaryResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetNetflowsSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetNetflowsSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetNetflowsSummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetNetflowsSummaryResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetNetflowsTimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetNetflowsTimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesGroupResponseResult {
pub meta: RadarGetNetflowsTimeseriesGroupResponseResultMeta,
pub serie_0: RadarGetNetflowsTimeseriesGroupResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetNetflowsTimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetNetflowsTimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetNetflowsTimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetNetflowsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetNetflowsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetNetflowsTimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetNetflowsTimeseriesGroupResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetNetflowsTimeseriesGroupResponseResultSerie0 = super::shared::TimestampsObject;
pub type RadarGetNetflowsTimeseriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetNetflowsTimeseriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesResponseResult {
pub meta: RadarGetNetflowsTimeseriesResponseResultMeta,
pub serie_0: RadarGetNetflowsTimeseriesResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetNetflowsTimeseriesResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetNetflowsTimeseriesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetNetflowsTimeseriesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetNetflowsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetNetflowsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetNetflowsTimeseriesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetNetflowsTimeseriesResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetNetflowsTimeseriesResponseResultSerie0 = super::shared::TimestampsValuesObject;
pub type RadarGetNetflowsTopAsesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetNetflowsTopAsesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopAsesResponseResult {
pub meta: RadarGetNetflowsTopAsesResponseResultMeta,
pub top_0: Vec<RadarGetNetflowsTopAsesResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopAsesResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetNetflowsTopAsesResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetNetflowsTopAsesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetNetflowsTopAsesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopAsesResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetNetflowsTopAsesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetNetflowsTopAsesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetNetflowsTopAsesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetNetflowsTopAsesResponseResultMetaUnitsItem = super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopAsesResponseResultTop0Item {
#[serde(rename = "clientASN")]
pub client_asn: f64,
#[serde(rename = "clientASName")]
pub client_as_name: String,
pub value: String,
}
pub type RadarGetNetflowsTopLocationsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetNetflowsTopLocationsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopLocationsResponseResult {
pub meta: RadarGetNetflowsTopLocationsResponseResultMeta,
pub top_0: Vec<RadarGetNetflowsTopLocationsResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopLocationsResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetNetflowsTopLocationsResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetNetflowsTopLocationsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetNetflowsTopLocationsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetNetflowsTopLocationsResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetNetflowsTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetNetflowsTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetNetflowsTopLocationsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetNetflowsTopLocationsResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetNetflowsTopLocationsResponseResultTop0Item =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
pub type RadarGetOriginDetailsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetOriginDetailsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginDetailsResponseResult {
pub origin: RadarGetOriginDetailsResponseResultOrigin,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginDetailsResponseResultOrigin {
pub regions: Vec<RadarGetOriginDetailsResponseResultOriginRegionsItem>,
pub slug: String,
}
pub type RadarGetOriginDetailsResponseResultOriginRegionsItem = super::shared::RegionObject;
pub type RadarGetOriginPostQuantumSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetOriginPostQuantumSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginPostQuantumSummaryResponseResult {
pub meta: RadarGetOriginPostQuantumSummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginPostQuantumSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetOriginPostQuantumSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetOriginPostQuantumSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetOriginPostQuantumSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginPostQuantumSummaryResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetOriginPostQuantumSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetOriginPostQuantumSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetOriginPostQuantumSummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetOriginPostQuantumSummaryResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetOriginPostQuantumTimeseriesGroupsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetOriginPostQuantumTimeseriesGroupsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginPostQuantumTimeseriesGroupsResponseResult {
pub meta: RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMeta,
pub serie_0: RadarGetOriginPostQuantumTimeseriesGroupsResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaConfidenceInfo {
pub annotations: Vec<
RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaConfidenceInfoAnnotationsItem,
>,
pub level: i64,
}
pub type RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetOriginPostQuantumTimeseriesGroupsResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetOriginPostQuantumTimeseriesGroupsResponseResultSerie0 =
super::shared::TimestampsObject;
pub type RadarGetOriginsResponse = super::shared::ApiEnvelopeSuccess<RadarGetOriginsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsResponseResult {
pub origins: Vec<RadarGetOriginsResponseResultOriginsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsResponseResultOriginsItem {
pub regions: Vec<RadarGetOriginsResponseResultOriginsItemRegionsItem>,
pub slug: String,
}
pub type RadarGetOriginsResponseResultOriginsItemRegionsItem = super::shared::RegionObject;
pub type RadarGetOriginsSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetOriginsSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsSummaryResponseResult {
pub meta: RadarGetOriginsSummaryResponseResultMeta,
pub summary_0: serde_json::Value,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetOriginsSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetOriginsSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetOriginsSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsSummaryResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetOriginsSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetOriginsSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetOriginsSummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetOriginsSummaryResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetOriginsTimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetOriginsTimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesGroupResponseResult {
pub meta: RadarGetOriginsTimeseriesGroupResponseResultMeta,
pub serie_0: RadarGetOriginsTimeseriesGroupResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetOriginsTimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetOriginsTimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetOriginsTimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetOriginsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetOriginsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetOriginsTimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetOriginsTimeseriesGroupResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetOriginsTimeseriesGroupResponseResultSerie0 = super::shared::TimestampsObject;
pub type RadarGetOriginsTimeseriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetOriginsTimeseriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesResponseResult {
pub meta: RadarGetOriginsTimeseriesResponseResultMeta,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetOriginsTimeseriesResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetOriginsTimeseriesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetOriginsTimeseriesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesResponseResultMetaConfidenceInfo {
pub annotations: Vec<RadarGetOriginsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetOriginsTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetOriginsTimeseriesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetOriginsTimeseriesResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetPostQuantumTlsSupportResponse =
super::shared::ApiEnvelopeSuccess<RadarGetPostQuantumTlsSupportResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetPostQuantumTlsSupportResponseResult {
pub host: String,
pub kex: f64,
#[serde(rename = "kexName")]
pub kex_name: String,
pub pq: bool,
}
pub type RadarGetQualitySpeedHistogramResponse =
super::shared::ApiEnvelopeSuccess<RadarGetQualitySpeedHistogramResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedHistogramResponseResult {
pub histogram_0: RadarGetQualitySpeedHistogramResponseResultHistogram0,
pub meta: RadarGetQualitySpeedHistogramResponseResultMeta,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedHistogramResponseResultHistogram0 {
#[serde(rename = "bandwidthDownload")]
pub bandwidth_download: Vec<String>,
#[serde(rename = "bandwidthUpload")]
pub bandwidth_upload: Vec<String>,
#[serde(rename = "bucketMin")]
pub bucket_min: Vec<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedHistogramResponseResultMeta {
#[serde(rename = "bucketSize")]
pub bucket_size: i64,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetQualitySpeedHistogramResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetQualitySpeedHistogramResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
#[serde(rename = "totalTests")]
pub total_tests: Vec<i64>,
pub units: Vec<RadarGetQualitySpeedHistogramResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedHistogramResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetQualitySpeedHistogramResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetQualitySpeedHistogramResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetQualitySpeedHistogramResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetQualitySpeedHistogramResponseResultMetaUnitsItem = super::shared::NameValueObject;
pub type RadarGetQualitySpeedSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetQualitySpeedSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedSummaryResponseResult {
pub meta: RadarGetQualitySpeedSummaryResponseResultMeta,
pub summary_0: RadarGetQualitySpeedSummaryResponseResultSummary0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetQualitySpeedSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetQualitySpeedSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetQualitySpeedSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedSummaryResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetQualitySpeedSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetQualitySpeedSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetQualitySpeedSummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetQualitySpeedSummaryResponseResultMetaUnitsItem = super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedSummaryResponseResultSummary0 {
#[serde(rename = "bandwidthDownload")]
pub bandwidth_download: String,
#[serde(rename = "bandwidthUpload")]
pub bandwidth_upload: String,
#[serde(rename = "jitterIdle")]
pub jitter_idle: String,
#[serde(rename = "jitterLoaded")]
pub jitter_loaded: String,
#[serde(rename = "latencyIdle")]
pub latency_idle: String,
#[serde(rename = "latencyLoaded")]
pub latency_loaded: String,
#[serde(rename = "packetLoss")]
pub packet_loss: String,
}
pub type RadarGetQualitySpeedTopAsesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetQualitySpeedTopAsesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopAsesResponseResult {
pub meta: RadarGetQualitySpeedTopAsesResponseResultMeta,
pub top_0: Vec<RadarGetQualitySpeedTopAsesResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopAsesResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetQualitySpeedTopAsesResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetQualitySpeedTopAsesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetQualitySpeedTopAsesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopAsesResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetQualitySpeedTopAsesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetQualitySpeedTopAsesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetQualitySpeedTopAsesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetQualitySpeedTopAsesResponseResultMetaUnitsItem = super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopAsesResponseResultTop0Item {
#[serde(rename = "bandwidthDownload")]
pub bandwidth_download: String,
#[serde(rename = "bandwidthUpload")]
pub bandwidth_upload: String,
#[serde(rename = "clientASN")]
pub client_asn: f64,
#[serde(rename = "clientASName")]
pub client_as_name: String,
#[serde(rename = "jitterIdle")]
pub jitter_idle: String,
#[serde(rename = "jitterLoaded")]
pub jitter_loaded: String,
#[serde(rename = "latencyIdle")]
pub latency_idle: String,
#[serde(rename = "latencyLoaded")]
pub latency_loaded: String,
#[serde(rename = "numTests")]
pub num_tests: f64,
#[serde(rename = "rankPower")]
pub rank_power: f64,
}
pub type RadarGetQualitySpeedTopLocationsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetQualitySpeedTopLocationsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopLocationsResponseResult {
pub meta: RadarGetQualitySpeedTopLocationsResponseResultMeta,
pub top_0: Vec<RadarGetQualitySpeedTopLocationsResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopLocationsResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetQualitySpeedTopLocationsResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetQualitySpeedTopLocationsResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetQualitySpeedTopLocationsResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopLocationsResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetQualitySpeedTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetQualitySpeedTopLocationsResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetQualitySpeedTopLocationsResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetQualitySpeedTopLocationsResponseResultMetaUnitsItem =
super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetQualitySpeedTopLocationsResponseResultTop0Item {
#[serde(rename = "bandwidthDownload")]
pub bandwidth_download: String,
#[serde(rename = "bandwidthUpload")]
pub bandwidth_upload: String,
#[serde(rename = "clientCountryAlpha2")]
pub client_country_alpha2: String,
#[serde(rename = "clientCountryName")]
pub client_country_name: String,
#[serde(rename = "jitterIdle")]
pub jitter_idle: String,
#[serde(rename = "jitterLoaded")]
pub jitter_loaded: String,
#[serde(rename = "latencyIdle")]
pub latency_idle: String,
#[serde(rename = "latencyLoaded")]
pub latency_loaded: String,
#[serde(rename = "numTests")]
pub num_tests: f64,
#[serde(rename = "rankPower")]
pub rank_power: f64,
}
pub type RadarGetRankingInternetServicesCategoriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetRankingInternetServicesCategoriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingInternetServicesCategoriesResponseResult {
pub categories_0: Vec<RadarGetRankingInternetServicesCategoriesResponseResultCategories0Item>,
}
pub type RadarGetRankingInternetServicesCategoriesResponseResultCategories0Item =
super::shared::NameObject;
pub type RadarGetRankingInternetServicesTimeseriesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetRankingInternetServicesTimeseriesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingInternetServicesTimeseriesResponseResult {
pub meta: RadarGetRankingInternetServicesTimeseriesResponseResultMeta,
pub serie_0: RadarGetRankingInternetServicesTimeseriesResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingInternetServicesTimeseriesResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetRankingInternetServicesTimeseriesResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetRankingInternetServicesTimeseriesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetRankingInternetServicesTimeseriesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingInternetServicesTimeseriesResponseResultMetaConfidenceInfo {
pub annotations: Vec<
RadarGetRankingInternetServicesTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem,
>,
pub level: i64,
}
pub type RadarGetRankingInternetServicesTimeseriesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetRankingInternetServicesTimeseriesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetRankingInternetServicesTimeseriesResponseResultMetaUnitsItem =
super::shared::NameValueObject;
pub type RadarGetRankingInternetServicesTimeseriesResponseResultSerie0 =
super::shared::TimestampsObject;
pub type RadarGetRankingTopInternetServicesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetRankingTopInternetServicesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingTopInternetServicesResponseResult {
pub meta: RadarGetRankingTopInternetServicesResponseResultMeta,
pub top_0: Vec<RadarGetRankingTopInternetServicesResponseResultTop0Item>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingTopInternetServicesResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: Option<RadarGetRankingTopInternetServicesResponseResultMetaConfidenceInfo>,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetRankingTopInternetServicesResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetRankingTopInternetServicesResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingTopInternetServicesResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetRankingTopInternetServicesResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetRankingTopInternetServicesResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetRankingTopInternetServicesResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetRankingTopInternetServicesResponseResultMetaUnitsItem =
super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetRankingTopInternetServicesResponseResultTop0Item {
pub rank: i64,
pub service: String,
}
pub type RadarGetReportsDatasetsResponse =
super::shared::ApiEnvelopeSuccess<RadarGetReportsDatasetsResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetReportsDatasetsResponseResult {
pub datasets: Vec<RadarGetReportsDatasetsResponseResultDatasetsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetReportsDatasetsResponseResultDatasetsItem {
pub description: String,
pub id: i64,
pub meta: serde_json::Value,
pub tags: Vec<String>,
pub title: String,
#[serde(rename = "type")]
pub r#type: String,
}
pub type RadarGetSearchGlobalResponse =
super::shared::ApiEnvelopeSuccess<RadarGetSearchGlobalResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetSearchGlobalResponseResult {
pub search: Vec<RadarGetSearchGlobalResponseResultSearchItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetSearchGlobalResponseResultSearchItem {
pub code: String,
pub name: String,
#[serde(rename = "type")]
pub r#type: String,
}
pub type RadarGetTcpResetsTimeoutsSummaryResponse =
super::shared::ApiEnvelopeSuccess<RadarGetTcpResetsTimeoutsSummaryResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsSummaryResponseResult {
pub meta: RadarGetTcpResetsTimeoutsSummaryResponseResultMeta,
pub summary_0: RadarGetTcpResetsTimeoutsSummaryResponseResultSummary0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsSummaryResponseResultMeta {
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetTcpResetsTimeoutsSummaryResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetTcpResetsTimeoutsSummaryResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetTcpResetsTimeoutsSummaryResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsSummaryResponseResultMetaConfidenceInfo {
pub annotations:
Vec<RadarGetTcpResetsTimeoutsSummaryResponseResultMetaConfidenceInfoAnnotationsItem>,
pub level: i64,
}
pub type RadarGetTcpResetsTimeoutsSummaryResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetTcpResetsTimeoutsSummaryResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetTcpResetsTimeoutsSummaryResponseResultMetaUnitsItem =
super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsSummaryResponseResultSummary0 {
pub later_in_flow: String,
pub no_match: String,
pub post_ack: String,
pub post_psh: String,
pub post_syn: String,
}
pub type RadarGetTcpResetsTimeoutsTimeseriesGroupResponse =
super::shared::ApiEnvelopeSuccess<RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResult {
pub meta: RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMeta,
pub serie_0: RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultSerie0,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMeta {
#[serde(rename = "aggInterval")]
pub agg_interval: String,
#[serde(rename = "confidenceInfo")]
pub confidence_info: RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaConfidenceInfo,
#[serde(rename = "dateRange")]
pub date_range: Vec<RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaDateRangeItem>,
#[serde(rename = "lastUpdated")]
pub last_updated: String,
pub normalization: String,
pub units: Vec<RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaUnitsItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaConfidenceInfo {
pub annotations: Vec<
RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem,
>,
pub level: i64,
}
pub type RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaConfidenceInfoAnnotationsItem =
super::shared::RadarGetAiBotsSummaryResponseResultMetaConfidenceInfoAnnotationsItemShape;
pub type RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaDateRangeItem =
super::shared::EndTimeStartTimeObject;
pub type RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultMetaUnitsItem =
super::shared::NameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsTimeseriesGroupResponseResultSerie0 {
pub later_in_flow: Vec<String>,
pub no_match: Vec<String>,
pub post_ack: Vec<String>,
pub post_psh: Vec<String>,
pub post_syn: Vec<String>,
pub timestamps: Vec<String>,
}
pub type RadarGetTrafficAnomaliesResponse =
super::shared::ApiEnvelopeSuccess<RadarGetTrafficAnomaliesResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTrafficAnomaliesResponseResult {
#[serde(rename = "trafficAnomalies")]
pub traffic_anomalies: Vec<RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItem {
#[serde(rename = "asnDetails")]
pub asn_details: Option<RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemAsnDetails>,
#[serde(rename = "endDate")]
pub end_date: Option<String>,
#[serde(rename = "locationDetails")]
pub location_details:
Option<RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemLocationDetails>,
#[serde(rename = "originDetails")]
pub origin_details:
Option<RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemOriginDetails>,
#[serde(rename = "startDate")]
pub start_date: String,
pub status: String,
#[serde(rename = "type")]
pub r#type: String,
pub uuid: String,
#[serde(rename = "visibleInDataSources")]
pub visible_in_data_sources: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemAsnDetails {
pub asn: String,
pub locations:
Option<RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemAsnDetailsLocations>,
pub name: String,
}
pub type RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemAsnDetailsLocations =
super::shared::CodeNameObject;
pub type RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemLocationDetails =
super::shared::CodeNameObject;
pub type RadarGetTrafficAnomaliesResponseResultTrafficAnomaliesItemOriginDetails =
super::shared::NameOriginObject;
pub type RadarGetTrafficAnomaliesTopResponse =
super::shared::ApiEnvelopeSuccess<RadarGetTrafficAnomaliesTopResponseResult>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarGetTrafficAnomaliesTopResponseResult {
#[serde(rename = "trafficAnomalies")]
pub traffic_anomalies: Vec<RadarGetTrafficAnomaliesTopResponseResultTrafficAnomaliesItem>,
}
pub type RadarGetTrafficAnomaliesTopResponseResultTrafficAnomaliesItem =
super::shared::ClientCountryAlpha2ClientCountryNameValueObject;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarPostReportsDatasetDownloadUrlRequest {
#[serde(rename = "datasetId")]
pub dataset_id: i64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarPostReportsDatasetDownloadUrlResponse {
pub result: RadarPostReportsDatasetDownloadUrlResponseResult,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarPostReportsDatasetDownloadUrlResponseResult {
pub dataset: RadarPostReportsDatasetDownloadUrlResponseResultDataset,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct RadarPostReportsDatasetDownloadUrlResponseResultDataset {
pub url: String,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetAnnotationsArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub date_range: Option<String>,
pub date_start: Option<String>,
pub date_end: Option<String>,
pub data_source: Option<String>,
pub event_type: Option<String>,
pub asn: Option<String>,
pub location: Option<String>,
pub origin: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetAnnotationsOutagesArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub date_range: Option<String>,
pub date_start: Option<String>,
pub date_end: Option<String>,
pub asn: Option<String>,
pub location: Option<String>,
pub origin: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetAnnotationsOutagesTopArgs {
pub limit: Option<String>,
pub date_range: Option<String>,
pub date_start: Option<String>,
pub date_end: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112SummaryArgs {
pub dimension: String,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub query_type: Vec<String>,
pub protocol: Vec<String>,
pub response_code: Vec<String>,
pub limit_per_group: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesArgs {
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub query_type: Vec<String>,
pub protocol: Vec<String>,
pub response_code: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112TimeseriesGroupArgs {
pub dimension: String,
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub query_type: Vec<String>,
pub protocol: Vec<String>,
pub response_code: Vec<String>,
pub limit_per_group: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsArgs {
pub limit: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByDnssecArgs {
pub dnssec: String,
pub limit: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByEdnsArgs {
pub edns: String,
pub limit: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetDnsAs112TopLocationsByIpVersionArgs {
pub ip_version: String,
pub limit: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
pub type RadarGetCertificateAuthoritiesArgs = super::shared::LimitOffsetFormatArgs;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetCertificateAuthorityDetailsArgs {
pub ca_slug: String,
pub format: Option<String>,
}
pub type RadarGetCertificateLogsArgs = super::shared::LimitOffsetFormatArgs;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetCertificateLogDetailsArgs {
pub log_slug: String,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetCtSummaryArgs {
pub dimension: String,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub limit_per_group: Option<String>,
pub ca: Vec<String>,
pub ca_owner: Vec<String>,
pub duration: Vec<String>,
pub entry_type: Vec<String>,
pub expiration_status: Vec<String>,
pub has_ips: Vec<String>,
pub has_wildcards: Vec<String>,
pub log: Vec<String>,
pub log_api: Vec<String>,
pub log_operator: Vec<String>,
pub public_key_algorithm: Vec<String>,
pub signature_algorithm: Vec<String>,
pub tld: Vec<String>,
pub validation_level: Vec<String>,
pub unique_entries: Vec<String>,
pub normalization: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetCtTimeseriesArgs {
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub ca: Vec<String>,
pub ca_owner: Vec<String>,
pub duration: Vec<String>,
pub entry_type: Vec<String>,
pub expiration_status: Vec<String>,
pub has_ips: Vec<String>,
pub has_wildcards: Vec<String>,
pub log: Vec<String>,
pub log_api: Vec<String>,
pub log_operator: Vec<String>,
pub public_key_algorithm: Vec<String>,
pub signature_algorithm: Vec<String>,
pub tld: Vec<String>,
pub validation_level: Vec<String>,
pub unique_entries: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetCtTimeseriesGroupArgs {
pub dimension: String,
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub limit_per_group: Option<String>,
pub ca: Vec<String>,
pub ca_owner: Vec<String>,
pub duration: Vec<String>,
pub entry_type: Vec<String>,
pub expiration_status: Vec<String>,
pub has_ips: Vec<String>,
pub has_wildcards: Vec<String>,
pub log: Vec<String>,
pub log_api: Vec<String>,
pub log_operator: Vec<String>,
pub public_key_algorithm: Vec<String>,
pub signature_algorithm: Vec<String>,
pub validation_level: Vec<String>,
pub tld: Vec<String>,
pub normalization: Option<String>,
pub unique_entries: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetReportsDatasetsArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub dataset_type: Option<String>,
pub date: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarPostReportsDatasetDownloadUrlArgs {
pub format: Option<String>,
pub body: RadarPostReportsDatasetDownloadUrlRequest,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetReportsDatasetDownloadArgs {
pub alias: String,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEntitiesAsnListArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub asn: Option<String>,
pub location: Option<String>,
pub order_by: Option<String>,
pub format: Option<String>,
}
pub type RadarGetEntitiesAsnByIpArgs = super::shared::IpFormatArgs;
pub type RadarGetEntitiesAsnByIdArgs = super::shared::AsnFormatArgs;
pub type RadarGetAsnsAsSetArgs = super::shared::AsnFormatArgs;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetAsnsRelArgs {
pub asn: String,
pub asn2: Option<String>,
pub format: Option<String>,
}
pub type RadarGetEntitiesIpArgs = super::shared::IpFormatArgs;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEntitiesLocationsArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub location: Option<String>,
pub region: Option<String>,
pub subregion: Option<String>,
pub continent: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetEntitiesLocationByAlpha2Args {
pub location: String,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetGeolocationsArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub geo_id: Option<String>,
pub location: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetGeolocationDetailsArgs {
pub geo_id: String,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetHttpSummaryArgs {
pub dimension: String,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub geo_id: Vec<String>,
pub bot_class: Vec<String>,
pub device_type: Vec<String>,
pub http_protocol: Vec<String>,
pub http_version: Vec<String>,
pub ip_version: Vec<String>,
pub os: Vec<String>,
pub tls_version: Vec<String>,
pub limit_per_group: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetHttpTimeseriesArgs {
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub geo_id: Vec<String>,
pub normalization: Option<String>,
pub bot_class: Vec<String>,
pub device_type: Vec<String>,
pub http_protocol: Vec<String>,
pub http_version: Vec<String>,
pub ip_version: Vec<String>,
pub os: Vec<String>,
pub tls_version: Vec<String>,
pub browser_family: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetHttpTimeseriesGroupArgs {
pub dimension: String,
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub geo_id: Vec<String>,
pub limit_per_group: Option<String>,
pub bot_class: Vec<String>,
pub device_type: Vec<String>,
pub http_protocol: Vec<String>,
pub http_version: Vec<String>,
pub normalization: Option<String>,
pub ip_version: Vec<String>,
pub os: Vec<String>,
pub tls_version: Vec<String>,
pub format: Option<String>,
}
pub type RadarGetHttpTopAsesByHttpRequestsArgs =
super::shared::RadarGetHttpTopAsesByHttpRequestsArgsShape;
pub type RadarGetHttpTopAsesByBrowserFamilyArgs =
super::shared::RadarGetHttpTopAsesByBrowserFamilyArgsShape;
pub type RadarGetHttpTopAsesByDeviceTypeArgs =
super::shared::RadarGetHttpTopAsesByDeviceTypeArgsShape;
pub type RadarGetHttpTopAsesByHttpProtocolArgs =
super::shared::RadarGetHttpTopAsesByHttpProtocolArgsShape;
pub type RadarGetHttpTopAsesByHttpVersionArgs =
super::shared::RadarGetHttpTopAsesByHttpVersionArgsShape;
pub type RadarGetHttpTopAsesByIpVersionArgs =
super::shared::RadarGetHttpTopAsesByIpVersionArgsShape;
pub type RadarGetHttpTopAsesByOperatingSystemArgs =
super::shared::RadarGetHttpTopAsesByOperatingSystemArgsShape;
pub type RadarGetHttpTopAsesByTlsVersionArgs =
super::shared::RadarGetHttpTopAsesByTlsVersionArgsShape;
pub type RadarGetHttpTopLocationsByHttpRequestsArgs =
super::shared::RadarGetHttpTopAsesByHttpRequestsArgsShape;
pub type RadarGetHttpTopLocationsByBrowserFamilyArgs =
super::shared::RadarGetHttpTopAsesByBrowserFamilyArgsShape;
pub type RadarGetHttpTopLocationsByDeviceTypeArgs =
super::shared::RadarGetHttpTopAsesByDeviceTypeArgsShape;
pub type RadarGetHttpTopLocationsByHttpProtocolArgs =
super::shared::RadarGetHttpTopAsesByHttpProtocolArgsShape;
pub type RadarGetHttpTopLocationsByHttpVersionArgs =
super::shared::RadarGetHttpTopAsesByHttpVersionArgsShape;
pub type RadarGetHttpTopLocationsByIpVersionArgs =
super::shared::RadarGetHttpTopAsesByIpVersionArgsShape;
pub type RadarGetHttpTopLocationsByOperatingSystemArgs =
super::shared::RadarGetHttpTopAsesByOperatingSystemArgsShape;
pub type RadarGetHttpTopLocationsByTlsVersionArgs =
super::shared::RadarGetHttpTopAsesByTlsVersionArgsShape;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksSummaryArgs {
pub dimension: String,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub bot_class: Vec<String>,
pub compromised: Vec<String>,
pub limit_per_group: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetLeakedCredentialChecksTimeseriesGroupArgs {
pub dimension: String,
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub bot_class: Vec<String>,
pub compromised: Vec<String>,
pub check_result: Vec<String>,
pub limit_per_group: Option<String>,
pub normalization: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetNetflowsSummaryArgs {
pub dimension: String,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub geo_id: Vec<String>,
pub product: Vec<String>,
pub limit_per_group: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesArgs {
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub product: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub geo_id: Vec<String>,
pub normalization: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetNetflowsTimeseriesGroupArgs {
pub dimension: String,
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub geo_id: Vec<String>,
pub limit_per_group: Option<String>,
pub normalization: Option<String>,
pub product: Vec<String>,
pub format: Option<String>,
}
pub type RadarGetNetflowsTopAsesArgs = super::shared::RadarGetNetflowsTopAsesArgsShape;
pub type RadarGetNetflowsTopLocationsArgs = super::shared::RadarGetNetflowsTopAsesArgsShape;
pub type RadarGetOriginsArgs = super::shared::LimitOffsetFormatArgs;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetOriginsSummaryArgs {
pub dimension: String,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub limit_per_group: Option<String>,
pub origin: Vec<String>,
pub metric: Option<String>,
pub region: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesArgs {
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub origin: Vec<String>,
pub metric: Option<String>,
pub region: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetOriginsTimeseriesGroupArgs {
pub dimension: String,
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub limit_per_group: Option<String>,
pub origin: Vec<String>,
pub metric: Option<String>,
pub region: Vec<String>,
pub normalization: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetOriginDetailsArgs {
pub slug: String,
pub format: Option<String>,
}
pub type RadarGetOriginPostQuantumSummaryArgs =
super::shared::RadarGetOriginPostQuantumSummaryArgsShape;
pub type RadarGetOriginPostQuantumTimeseriesGroupsArgs =
super::shared::RadarGetOriginPostQuantumSummaryArgsShape;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetPostQuantumTlsSupportArgs {
pub host: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetQualitySpeedHistogramArgs {
pub name: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub bucket_size: Option<String>,
pub metric_group: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetQualitySpeedSummaryArgs {
pub name: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
pub type RadarGetQualitySpeedTopAsesArgs = super::shared::RadarGetQualitySpeedTopAsesArgsShape;
pub type RadarGetQualitySpeedTopLocationsArgs = super::shared::RadarGetQualitySpeedTopAsesArgsShape;
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetRankingInternetServicesCategoriesArgs {
pub limit: Option<String>,
pub name: Vec<String>,
pub date: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetRankingInternetServicesTimeseriesArgs {
pub service_category: Vec<String>,
pub limit: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetRankingTopInternetServicesArgs {
pub service_category: Vec<String>,
pub limit: Option<String>,
pub name: Vec<String>,
pub date: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetSearchGlobalArgs {
pub limit: Option<String>,
pub limit_per_group: Option<String>,
pub query: Option<String>,
pub include: Vec<String>,
pub exclude: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsSummaryArgs {
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetTcpResetsTimeoutsTimeseriesGroupArgs {
pub agg_interval: Option<String>,
pub name: Vec<String>,
pub date_range: Vec<String>,
pub date_start: Vec<String>,
pub date_end: Vec<String>,
pub asn: Vec<String>,
pub location: Vec<String>,
pub continent: Vec<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetTrafficAnomaliesArgs {
pub limit: Option<String>,
pub offset: Option<String>,
pub date_range: Option<String>,
pub date_start: Option<String>,
pub date_end: Option<String>,
pub status: Option<String>,
pub r#type: Vec<String>,
pub asn: Option<String>,
pub location: Option<String>,
pub origin: Option<String>,
pub format: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct RadarGetTrafficAnomaliesTopArgs {
pub limit: Option<String>,
pub date_range: Option<String>,
pub date_start: Option<String>,
pub date_end: Option<String>,
pub status: Option<String>,
pub format: Option<String>,
}
pub async fn radar_get_annotations_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetAnnotationsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetAnnotationsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/annotations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("dateRange", args.date_range.as_deref());
builder = builder.query("dateStart", args.date_start.as_deref());
builder = builder.query("dateEnd", args.date_end.as_deref());
builder = builder.query("dataSource", args.data_source.as_deref());
builder = builder.query("eventType", args.event_type.as_deref());
builder = builder.query("asn", args.asn.as_deref());
builder = builder.query("location", args.location.as_deref());
builder = builder.query("origin", args.origin.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_annotations_outages_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetAnnotationsOutagesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetAnnotationsOutagesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/annotations/outages",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("dateRange", args.date_range.as_deref());
builder = builder.query("dateStart", args.date_start.as_deref());
builder = builder.query("dateEnd", args.date_end.as_deref());
builder = builder.query("asn", args.asn.as_deref());
builder = builder.query("location", args.location.as_deref());
builder = builder.query("origin", args.origin.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_annotations_outages_top_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetAnnotationsOutagesTopArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetAnnotationsOutagesTopResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/annotations/outages/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("dateRange", args.date_range.as_deref());
builder = builder.query("dateStart", args.date_start.as_deref());
builder = builder.query("dateEnd", args.date_end.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112SummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112SummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.query_type {
builder = builder.query("queryType", Some(value.as_str()));
}
for value in &args.protocol {
builder = builder.query("protocol", Some(value.as_str()));
}
for value in &args.response_code {
builder = builder.query("responseCode", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_timeseries_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112TimeseriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112TimeseriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/timeseries",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.query_type {
builder = builder.query("queryType", Some(value.as_str()));
}
for value in &args.protocol {
builder = builder.query("protocol", Some(value.as_str()));
}
for value in &args.response_code {
builder = builder.query("responseCode", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112TimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112TimeseriesGroupResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/timeseries_groups/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.query_type {
builder = builder.query("queryType", Some(value.as_str()));
}
for value in &args.protocol {
builder = builder.query("protocol", Some(value.as_str()));
}
for value in &args.response_code {
builder = builder.query("responseCode", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_top_locations_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112TopLocationsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112TopLocationsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/top/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_top_locations_by_dnssec_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112TopLocationsByDnssecArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112TopLocationsByDnssecResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/top/locations/dnssec/{}", args.dnssec,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_top_locations_by_edns_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112TopLocationsByEdnsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112TopLocationsByEdnsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/top/locations/edns/{}", args.edns,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_dns_as112_top_locations_by_ip_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetDnsAs112TopLocationsByIpVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetDnsAs112TopLocationsByIpVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/as112/top/locations/ip_version/{}", args.ip_version,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_certificate_authorities_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCertificateAuthoritiesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCertificateAuthoritiesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/authorities",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_certificate_authority_details_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCertificateAuthorityDetailsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCertificateAuthorityDetailsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/authorities/{}", args.ca_slug,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_certificate_logs_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCertificateLogsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCertificateLogsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/logs",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_certificate_log_details_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCertificateLogDetailsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCertificateLogDetailsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/logs/{}", args.log_slug,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_ct_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCtSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCtSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
for value in &args.ca {
builder = builder.query("ca", Some(value.as_str()));
}
for value in &args.ca_owner {
builder = builder.query("caOwner", Some(value.as_str()));
}
for value in &args.duration {
builder = builder.query("duration", Some(value.as_str()));
}
for value in &args.entry_type {
builder = builder.query("entryType", Some(value.as_str()));
}
for value in &args.expiration_status {
builder = builder.query("expirationStatus", Some(value.as_str()));
}
for value in &args.has_ips {
builder = builder.query("hasIps", Some(value.as_str()));
}
for value in &args.has_wildcards {
builder = builder.query("hasWildcards", Some(value.as_str()));
}
for value in &args.log {
builder = builder.query("log", Some(value.as_str()));
}
for value in &args.log_api {
builder = builder.query("logApi", Some(value.as_str()));
}
for value in &args.log_operator {
builder = builder.query("logOperator", Some(value.as_str()));
}
for value in &args.public_key_algorithm {
builder = builder.query("publicKeyAlgorithm", Some(value.as_str()));
}
for value in &args.signature_algorithm {
builder = builder.query("signatureAlgorithm", Some(value.as_str()));
}
for value in &args.tld {
builder = builder.query("tld", Some(value.as_str()));
}
for value in &args.validation_level {
builder = builder.query("validationLevel", Some(value.as_str()));
}
for value in &args.unique_entries {
builder = builder.query("uniqueEntries", Some(value.as_str()));
}
builder = builder.query("normalization", args.normalization.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_ct_timeseries_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCtTimeseriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCtTimeseriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/timeseries",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.ca {
builder = builder.query("ca", Some(value.as_str()));
}
for value in &args.ca_owner {
builder = builder.query("caOwner", Some(value.as_str()));
}
for value in &args.duration {
builder = builder.query("duration", Some(value.as_str()));
}
for value in &args.entry_type {
builder = builder.query("entryType", Some(value.as_str()));
}
for value in &args.expiration_status {
builder = builder.query("expirationStatus", Some(value.as_str()));
}
for value in &args.has_ips {
builder = builder.query("hasIps", Some(value.as_str()));
}
for value in &args.has_wildcards {
builder = builder.query("hasWildcards", Some(value.as_str()));
}
for value in &args.log {
builder = builder.query("log", Some(value.as_str()));
}
for value in &args.log_api {
builder = builder.query("logApi", Some(value.as_str()));
}
for value in &args.log_operator {
builder = builder.query("logOperator", Some(value.as_str()));
}
for value in &args.public_key_algorithm {
builder = builder.query("publicKeyAlgorithm", Some(value.as_str()));
}
for value in &args.signature_algorithm {
builder = builder.query("signatureAlgorithm", Some(value.as_str()));
}
for value in &args.tld {
builder = builder.query("tld", Some(value.as_str()));
}
for value in &args.validation_level {
builder = builder.query("validationLevel", Some(value.as_str()));
}
for value in &args.unique_entries {
builder = builder.query("uniqueEntries", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_ct_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetCtTimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetCtTimeseriesGroupResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ct/timeseries_groups/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
for value in &args.ca {
builder = builder.query("ca", Some(value.as_str()));
}
for value in &args.ca_owner {
builder = builder.query("caOwner", Some(value.as_str()));
}
for value in &args.duration {
builder = builder.query("duration", Some(value.as_str()));
}
for value in &args.entry_type {
builder = builder.query("entryType", Some(value.as_str()));
}
for value in &args.expiration_status {
builder = builder.query("expirationStatus", Some(value.as_str()));
}
for value in &args.has_ips {
builder = builder.query("hasIps", Some(value.as_str()));
}
for value in &args.has_wildcards {
builder = builder.query("hasWildcards", Some(value.as_str()));
}
for value in &args.log {
builder = builder.query("log", Some(value.as_str()));
}
for value in &args.log_api {
builder = builder.query("logApi", Some(value.as_str()));
}
for value in &args.log_operator {
builder = builder.query("logOperator", Some(value.as_str()));
}
for value in &args.public_key_algorithm {
builder = builder.query("publicKeyAlgorithm", Some(value.as_str()));
}
for value in &args.signature_algorithm {
builder = builder.query("signatureAlgorithm", Some(value.as_str()));
}
for value in &args.validation_level {
builder = builder.query("validationLevel", Some(value.as_str()));
}
for value in &args.tld {
builder = builder.query("tld", Some(value.as_str()));
}
builder = builder.query("normalization", args.normalization.as_deref());
for value in &args.unique_entries {
builder = builder.query("uniqueEntries", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_reports_datasets_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetReportsDatasetsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetReportsDatasetsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/datasets",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("datasetType", args.dataset_type.as_deref());
builder = builder.query("date", args.date.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_post_reports_dataset_download_url_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarPostReportsDatasetDownloadUrlArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarPostReportsDatasetDownloadUrlResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/datasets/download",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::post(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
builder = builder
.body_json(&args.body)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_reports_dataset_download_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetReportsDatasetDownloadArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<super::shared::ByteStream>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/datasets/{}", args.alias,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_bytes(client.into(), builder.build()).await
}
pub async fn radar_get_entities_asn_list_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetEntitiesAsnListArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEntitiesAsnListResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/asns",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("asn", args.asn.as_deref());
builder = builder.query("location", args.location.as_deref());
builder = builder.query("orderBy", args.order_by.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_entities_asn_by_ip_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetEntitiesAsnByIpArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEntitiesAsnByIpResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/asns/ip",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("ip", args.ip.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_entities_asn_by_id_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetEntitiesAsnByIdArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEntitiesAsnByIdResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/asns/{}", args.asn,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_asns_as_set_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetAsnsAsSetArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetAsnsAsSetResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/asns/{}/as_set", args.asn,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_asns_rel_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetAsnsRelArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetAsnsRelResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/asns/{}/rel", args.asn,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("asn2", args.asn2.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_entities_ip_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetEntitiesIpArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEntitiesIpResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/ip",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("ip", args.ip.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_entities_locations_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetEntitiesLocationsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEntitiesLocationsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("location", args.location.as_deref());
builder = builder.query("region", args.region.as_deref());
builder = builder.query("subregion", args.subregion.as_deref());
builder = builder.query("continent", args.continent.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_entities_location_by_alpha2_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetEntitiesLocationByAlpha2Args,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetEntitiesLocationByAlpha2Response>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/entities/locations/{}", args.location,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_geolocations_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetGeolocationsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetGeolocationsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/geolocations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("geoId", args.geo_id.as_deref());
builder = builder.query("location", args.location.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_geolocation_details_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetGeolocationDetailsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetGeolocationDetailsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/geolocations/{}", args.geo_id,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_timeseries_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTimeseriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTimeseriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/timeseries",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
builder = builder.query("normalization", args.normalization.as_deref());
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTimeseriesGroupResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/timeseries_groups/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
builder = builder.query("normalization", args.normalization.as_deref());
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_http_requests_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByHttpRequestsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByHttpRequestsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_browser_family_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByBrowserFamilyArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByBrowserFamilyResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!(
"/radar/http/top/ases/browser_family/{}",
args.browser_family,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_device_type_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByDeviceTypeArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByDeviceTypeResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases/device_type/{}", args.device_type,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_http_protocol_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByHttpProtocolArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByHttpProtocolResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases/http_protocol/{}", args.http_protocol,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_http_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByHttpVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByHttpVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases/http_version/{}", args.http_version,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_ip_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByIpVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByIpVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases/ip_version/{}", args.ip_version,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_operating_system_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByOperatingSystemArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByOperatingSystemResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases/os/{}", args.os,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_ases_by_tls_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopAsesByTlsVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopAsesByTlsVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/ases/tls_version/{}", args.tls_version,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_http_requests_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByHttpRequestsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByHttpRequestsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_browser_family_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByBrowserFamilyArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByBrowserFamilyResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!(
"/radar/http/top/locations/browser_family/{}",
args.browser_family,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_device_type_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByDeviceTypeArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByDeviceTypeResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/locations/device_type/{}", args.device_type,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_http_protocol_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByHttpProtocolArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByHttpProtocolResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!(
"/radar/http/top/locations/http_protocol/{}",
args.http_protocol,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_http_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByHttpVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByHttpVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!(
"/radar/http/top/locations/http_version/{}",
args.http_version,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_ip_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByIpVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByIpVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/locations/ip_version/{}", args.ip_version,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_operating_system_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByOperatingSystemArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByOperatingSystemResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/locations/os/{}", args.os,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.tls_version {
builder = builder.query("tlsVersion", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_http_top_locations_by_tls_version_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetHttpTopLocationsByTlsVersionArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetHttpTopLocationsByTlsVersionResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/http/top/locations/tls_version/{}", args.tls_version,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.device_type {
builder = builder.query("deviceType", Some(value.as_str()));
}
for value in &args.http_protocol {
builder = builder.query("httpProtocol", Some(value.as_str()));
}
for value in &args.http_version {
builder = builder.query("httpVersion", Some(value.as_str()));
}
for value in &args.ip_version {
builder = builder.query("ipVersion", Some(value.as_str()));
}
for value in &args.os {
builder = builder.query("os", Some(value.as_str()));
}
for value in &args.browser_family {
builder = builder.query("browserFamily", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_leaked_credential_checks_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetLeakedCredentialChecksSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetLeakedCredentialChecksSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/leaked_credential_checks/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.compromised {
builder = builder.query("compromised", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_leaked_credential_checks_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetLeakedCredentialChecksTimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<
ApiResponse<RadarGetLeakedCredentialChecksTimeseriesGroupResponse>,
super::shared::ApiError,
>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!(
"/radar/leaked_credential_checks/timeseries_groups/{}",
args.dimension,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.bot_class {
builder = builder.query("botClass", Some(value.as_str()));
}
for value in &args.compromised {
builder = builder.query("compromised", Some(value.as_str()));
}
for value in &args.check_result {
builder = builder.query("checkResult", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("normalization", args.normalization.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_netflows_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetNetflowsSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetNetflowsSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/netflows/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
for value in &args.product {
builder = builder.query("product", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_netflows_timeseries_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetNetflowsTimeseriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetNetflowsTimeseriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/netflows/timeseries",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.product {
builder = builder.query("product", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
builder = builder.query("normalization", args.normalization.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_netflows_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetNetflowsTimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetNetflowsTimeseriesGroupResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/netflows/timeseries_groups/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("normalization", args.normalization.as_deref());
for value in &args.product {
builder = builder.query("product", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_netflows_top_ases_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetNetflowsTopAsesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetNetflowsTopAsesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/netflows/top/ases",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_netflows_top_locations_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetNetflowsTopLocationsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetNetflowsTopLocationsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/netflows/top/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
for value in &args.geo_id {
builder = builder.query("geoId", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origins_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/origins",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origins_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginsSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginsSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/origins/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
for value in &args.origin {
builder = builder.query("origin", Some(value.as_str()));
}
builder = builder.query("metric", args.metric.as_deref());
for value in &args.region {
builder = builder.query("region", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origins_timeseries_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginsTimeseriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginsTimeseriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/origins/timeseries",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.origin {
builder = builder.query("origin", Some(value.as_str()));
}
builder = builder.query("metric", args.metric.as_deref());
for value in &args.region {
builder = builder.query("region", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origins_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginsTimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginsTimeseriesGroupResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/origins/timeseries_groups/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
for value in &args.origin {
builder = builder.query("origin", Some(value.as_str()));
}
builder = builder.query("metric", args.metric.as_deref());
for value in &args.region {
builder = builder.query("region", Some(value.as_str()));
}
builder = builder.query("normalization", args.normalization.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origin_details_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginDetailsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginDetailsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/origins/{}", args.slug,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origin_post_quantum_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginPostQuantumSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginPostQuantumSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/post_quantum/origin/summary/{}", args.dimension,);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_origin_post_quantum_timeseries_groups_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetOriginPostQuantumTimeseriesGroupsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetOriginPostQuantumTimeseriesGroupsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!(
"/radar/post_quantum/origin/timeseries_groups/{}",
args.dimension,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_post_quantum_tls_support_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetPostQuantumTlsSupportArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetPostQuantumTlsSupportResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/post_quantum/tls/support",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("host", args.host.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_quality_speed_histogram_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetQualitySpeedHistogramArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetQualitySpeedHistogramResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/quality/speed/histogram",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("bucketSize", args.bucket_size.as_deref());
builder = builder.query("metricGroup", args.metric_group.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_quality_speed_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetQualitySpeedSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetQualitySpeedSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/quality/speed/summary",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_quality_speed_top_ases_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetQualitySpeedTopAsesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetQualitySpeedTopAsesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/quality/speed/top/ases",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("orderBy", args.order_by.as_deref());
builder = builder.query("reverse", args.reverse.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_quality_speed_top_locations_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetQualitySpeedTopLocationsArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetQualitySpeedTopLocationsResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/quality/speed/top/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("orderBy", args.order_by.as_deref());
builder = builder.query("reverse", args.reverse.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_ranking_internet_services_categories_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetRankingInternetServicesCategoriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetRankingInternetServicesCategoriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ranking/internet_services/categories",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date {
builder = builder.query("date", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_ranking_internet_services_timeseries_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetRankingInternetServicesTimeseriesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetRankingInternetServicesTimeseriesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ranking/internet_services/timeseries_groups",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.service_category {
builder = builder.query("serviceCategory", Some(value.as_str()));
}
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_ranking_top_internet_services_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetRankingTopInternetServicesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetRankingTopInternetServicesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/ranking/internet_services/top",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.service_category {
builder = builder.query("serviceCategory", Some(value.as_str()));
}
builder = builder.query("limit", args.limit.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date {
builder = builder.query("date", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_search_global_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetSearchGlobalArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetSearchGlobalResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/search/global",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("limitPerGroup", args.limit_per_group.as_deref());
builder = builder.query("query", args.query.as_deref());
for value in &args.include {
builder = builder.query("include", Some(value.as_str()));
}
for value in &args.exclude {
builder = builder.query("exclude", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_tcp_resets_timeouts_summary_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetTcpResetsTimeoutsSummaryArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetTcpResetsTimeoutsSummaryResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/tcp_resets_timeouts/summary",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_tcp_resets_timeouts_timeseries_group_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetTcpResetsTimeoutsTimeseriesGroupArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetTcpResetsTimeoutsTimeseriesGroupResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/tcp_resets_timeouts/timeseries_groups",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("aggInterval", args.agg_interval.as_deref());
for value in &args.name {
builder = builder.query("name", Some(value.as_str()));
}
for value in &args.date_range {
builder = builder.query("dateRange", Some(value.as_str()));
}
for value in &args.date_start {
builder = builder.query("dateStart", Some(value.as_str()));
}
for value in &args.date_end {
builder = builder.query("dateEnd", Some(value.as_str()));
}
for value in &args.asn {
builder = builder.query("asn", Some(value.as_str()));
}
for value in &args.location {
builder = builder.query("location", Some(value.as_str()));
}
for value in &args.continent {
builder = builder.query("continent", Some(value.as_str()));
}
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_traffic_anomalies_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetTrafficAnomaliesArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetTrafficAnomaliesResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/traffic_anomalies",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("offset", args.offset.as_deref());
builder = builder.query("dateRange", args.date_range.as_deref());
builder = builder.query("dateStart", args.date_start.as_deref());
builder = builder.query("dateEnd", args.date_end.as_deref());
builder = builder.query("status", args.status.as_deref());
for value in &args.r#type {
builder = builder.query("type", Some(value.as_str()));
}
builder = builder.query("asn", args.asn.as_deref());
builder = builder.query("location", args.location.as_deref());
builder = builder.query("origin", args.origin.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}
pub async fn radar_get_traffic_anomalies_top_request<F>(
client: impl Into<super::shared::ApiClient>,
args: &RadarGetTrafficAnomaliesTopArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<RadarGetTrafficAnomaliesTopResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/radar/traffic_anomalies/locations",);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("limit", args.limit.as_deref());
builder = builder.query("dateRange", args.date_range.as_deref());
builder = builder.query("dateStart", args.date_start.as_deref());
builder = builder.query("dateEnd", args.date_end.as_deref());
builder = builder.query("status", args.status.as_deref());
builder = builder.query("format", args.format.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
super::shared::send_json(client.into(), builder.build()).await
}