foundation_deployment_cloudflare 0.1.2

//! Auto-generated API module for cloudflare data.
//!
//! Generated by `cargo run --bin ewe_platform gen_api`.
//! DO NOT EDIT MANUALLY.
//!
//! Feature flag: `cloudflare_data `

#![cfg(feature = "cloudflare_data")]
#![allow(clippy::too_many_arguments, clippy::type_complexity)]
#![allow(clippy::missing_errors_doc, clippy::doc_markdown, clippy::useless_format)]
#![allow(unused_imports)]

use foundation_netio::{DynNetClient, PreparedRequestBuilder};
use foundation_netio::shared::client::http_client::HttpClient;
use serde::{Deserialize, Serialize};
use foundation_macros::JsonHash;

use super::shared::ApiResponse;

// =============================================================================
// TYPE DECLARATIONS
// =============================================================================

/// `DlpApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpApiResponseCommon {
    /// errors property.
    pub errors: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// messages property.
    pub messages: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// success property.
    pub success: bool,
}

/// `DlpApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpApiResponseSingle {
}

/// `DlpContextAwareness` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpContextAwareness {
    /// enabled property.
    pub enabled: bool,
    /// skip property.
    pub skip: DlpSkipConfig,
}

/// `DlpCustomEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCustomEntry {
    /// created_at property.
    pub created_at: String,
    /// description property.
    pub description: Option<String>,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// pattern property.
    pub pattern: DlpPattern,
    /// profile_id property.
    pub profile_id: Option<String>,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpCustomEntryUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCustomEntryUpdate {
    /// `enabled` property.
    pub enabled: bool,
}

/// `DlpCustomEntryUpdateType` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCustomEntryUpdateType {
    /// description property.
    pub description: Option<String>,
    /// name property.
    pub name: String,
    /// pattern property.
    pub pattern: DlpPattern,
}

/// `DlpCustomProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCustomProfile {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: i64,
    /// confidence_threshold property.
    pub confidence_threshold: Option<serde_json::Value>,
    /// context_awareness property.
    pub context_awareness: Option<DlpContextAwareness>,
    /// created_at property.
    pub created_at: String,
    /// data_classes property.
    pub data_classes: Option<Vec<String>>,
    /// data_tags property.
    pub data_tags: Option<Vec<String>>,
    /// description property.
    pub description: Option<String>,
    /// entries property.
    pub entries: Option<Vec<DlpEntry>>,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// ocr_enabled property.
    pub ocr_enabled: bool,
    /// sensitivity_levels property.
    pub sensitivity_levels: Option<Vec<DlpSensitivityLevelRef>>,
    /// shared_entries property.
    pub shared_entries: Option<Vec<DlpEntry>>,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpCustomProfileArray` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCustomProfileArray {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpCustomProfileUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpCustomProfileUpdate {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: Option<i64>,
    /// confidence_threshold property.
    pub confidence_threshold: Option<String>,
    /// context_awareness property.
    pub context_awareness: Option<DlpContextAwareness>,
    /// data_classes property.
    pub data_classes: Option<Vec<String>>,
    /// data_tags property.
    pub data_tags: Option<Vec<String>>,
    /// description property.
    pub description: Option<String>,
    /// entries property.
    pub entries: Option<Vec<DlpProfileEntryUpdate>>,
    /// name property.
    pub name: String,
    /// ocr_enabled property.
    pub ocr_enabled: Option<bool>,
    /// sensitivity_levels property.
    pub sensitivity_levels: Option<Vec<DlpSensitivityLevelRef>>,
    /// shared_entries property.
    pub shared_entries: Option<Vec<DlpSharedEntryUpdate>>,
}

/// `DlpDataset` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDataset {
    /// case_sensitive property.
    pub case_sensitive: Option<bool>,
    /// columns property.
    pub columns: Vec<DlpDatasetColumn>,
    /// created_at property.
    pub created_at: String,
    /// description property.
    pub description: Option<String>,
    /// encoding_version property.
    pub encoding_version: i64,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// num_cells property.
    pub num_cells: i64,
    /// secret property.
    pub secret: bool,
    /// status property.
    pub status: DlpDatasetUploadStatus,
    /// updated_at property.
    pub updated_at: String,
    /// uploads property.
    pub uploads: Vec<DlpDatasetUpload>,
}

/// `DlpDatasetArray` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetArray {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpDatasetColumn` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetColumn {
    /// entry_id property.
    pub entry_id: String,
    /// header_name property.
    pub header_name: String,
    /// num_cells property.
    pub num_cells: i64,
    /// upload_status property.
    pub upload_status: DlpDatasetUploadStatus,
}

/// `DlpDatasetColumnArray` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetColumnArray {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpDatasetCreation` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetCreation {
    /// dataset property.
    pub dataset: DlpDataset,
    /// encoding_version property.
    pub encoding_version: i64,
    /// max_cells property.
    pub max_cells: i64,
    /// secret property.
    pub secret: Option<String>,
    /// version property.
    pub version: i64,
}

/// `DlpDatasetNewVersion` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetNewVersion {
    /// case_sensitive property.
    pub case_sensitive: Option<bool>,
    /// columns property.
    pub columns: Option<Vec<DlpDatasetColumn>>,
    /// encoding_version property.
    pub encoding_version: i64,
    /// max_cells property.
    pub max_cells: i64,
    /// secret property.
    pub secret: Option<String>,
    /// version property.
    pub version: i64,
}

/// `DlpDatasetUpload` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetUpload {
    /// num_cells property.
    pub num_cells: i64,
    /// status property.
    pub status: DlpDatasetUploadStatus,
    /// version property.
    pub version: i64,
}

/// `DlpDatasetUploadStatus` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetUploadStatus {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpDatasetsCreateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsCreateRequest {
    /// case_sensitive property.
    pub case_sensitive: Option<bool>,
    /// description property.
    pub description: Option<String>,
    /// encoding_version property.
    pub encoding_version: Option<i64>,
    /// name property.
    pub name: String,
    /// secret property.
    pub secret: Option<bool>,
}

/// `DlpDatasetsCreateResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsCreateResponse {
    /// `result` property.
    pub result: Option<DlpDatasetCreation>,
}

/// `DlpDatasetsCreateVersionResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsCreateVersionResponse {
    /// `result` property.
    pub result: Option<DlpDatasetNewVersion>,
}

/// `DlpDatasetsDefineColumnsRequestItem` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsDefineColumnsRequestItem {
    /// `header_name` property.
    pub header_name: String,
    /// `num_cells` property.
    pub num_cells: i64,
}

/// `DlpDatasetsDefineColumnsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsDefineColumnsResponse {
    /// `result` property.
    pub result: Option<Vec<DlpDatasetColumn>>,
}

/// `DlpDatasetsReadAllResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsReadAllResponse {
    /// `result` property.
    pub result: Option<Vec<DlpDataset>>,
}

/// `DlpDatasetsReadResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsReadResponse {
    /// `result` property.
    pub result: Option<DlpDataset>,
}

/// `DlpDatasetsUpdateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsUpdateRequest {
    /// case_sensitive property.
    pub case_sensitive: Option<bool>,
    /// description property.
    pub description: Option<String>,
    /// name property.
    pub name: Option<String>,
}

/// `DlpDatasetsUpdateResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsUpdateResponse {
    /// `result` property.
    pub result: Option<DlpDataset>,
}

/// `DlpDatasetsUploadDatasetColumnResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsUploadDatasetColumnResponse {
    /// `result` property.
    pub result: Option<DlpDatasetColumn>,
}

/// `DlpDatasetsUploadVersionResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDatasetsUploadVersionResponse {
    /// `result` property.
    pub result: Option<DlpDataset>,
}

/// `DlpDlpSettings` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDlpSettings {
    /// ai_context_analysis property.
    pub ai_context_analysis: bool,
    /// ocr property.
    pub ocr: bool,
    /// payload_logging property.
    pub payload_logging: DlpPayloadLogSetting,
}

/// `DlpDlpSettingsUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDlpSettingsUpdate {
    /// ai_context_analysis property.
    pub ai_context_analysis: Option<bool>,
    /// ocr property.
    pub ocr: Option<bool>,
    /// payload_logging property.
    pub payload_logging: Option<serde_json::Value>,
}

/// `DlpDocumentFingerprintEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpDocumentFingerprintEntry {
    /// created_at property.
    pub created_at: String,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpEmpty` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEmpty {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpEntriesCreateEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesCreateEntryResponse {
    /// `result` property.
    pub result: Option<DlpCustomEntry>,
}

/// `DlpEntriesCreateIntegrationEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesCreateIntegrationEntryResponse {
    /// `result` property.
    pub result: Option<DlpIntegrationEntry>,
}

/// `DlpEntriesCreatePredefinedEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesCreatePredefinedEntryResponse {
    /// `result` property.
    pub result: Option<DlpPredefinedEntry>,
}

/// `DlpEntriesDeleteEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesDeleteEntryResponse {
    /// `result` property.
    pub result: Option<DlpEmpty>,
}

/// `DlpEntriesDeleteIntegrationEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesDeleteIntegrationEntryResponse {
    /// `result` property.
    pub result: Option<DlpEmpty>,
}

/// `DlpEntriesDeletePredefinedEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesDeletePredefinedEntryResponse {
    /// `result` property.
    pub result: Option<DlpEmpty>,
}

/// `DlpEntriesGetDlpEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesGetDlpEntryResponse {
    /// `result` property.
    pub result: Option<DlpEntryWithSharedProfiles>,
}

/// `DlpEntriesListAllEntriesResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesListAllEntriesResponse {
    /// `result` property.
    pub result: Option<Vec<DlpEntryWithUploadStatus>>,
}

/// `DlpEntriesUpdateCustomEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesUpdateCustomEntryResponse {
    /// `result` property.
    pub result: Option<DlpCustomEntry>,
}

/// `DlpEntriesUpdateEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesUpdateEntryResponse {
    /// `result` property.
    pub result: Option<DlpEntry>,
}

/// `DlpEntriesUpdateIntegrationEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesUpdateIntegrationEntryResponse {
    /// `result` property.
    pub result: Option<DlpIntegrationEntry>,
}

/// `DlpEntriesUpdatePredefinedEntryResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntriesUpdatePredefinedEntryResponse {
    /// `result` property.
    pub result: Option<DlpPredefinedEntry>,
}

/// `DlpEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntry {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpEntryConfidence` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryConfidence {
    /// ai_context_available property.
    pub ai_context_available: bool,
    /// available property.
    pub available: bool,
}

/// `DlpEntryOfNewProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryOfNewProfile {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpEntryProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryProfile {
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
}

/// `DlpEntryUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryUpdate {
    /// `enabled` property.
    pub enabled: bool,
}

/// `DlpEntryUpdateType` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryUpdateType {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpEntryWithSharedProfiles` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryWithSharedProfiles {
    /// `profiles` property.
    pub profiles: Vec<DlpEntryProfile>,
}

/// `DlpEntryWithUploadStatus` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpEntryWithUploadStatus {
    /// `upload_status` property.
    pub upload_status: Option<serde_json::Value>,
}

/// `DlpExactDataEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpExactDataEntry {
    /// case_sensitive property.
    pub case_sensitive: bool,
    /// created_at property.
    pub created_at: String,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// secret property.
    pub secret: bool,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpIntegrationEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpIntegrationEntry {
    /// created_at property.
    pub created_at: String,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// profile_id property.
    pub profile_id: Option<String>,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpIntegrationProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpIntegrationProfile {
    /// created_at property.
    pub created_at: String,
    /// description property.
    pub description: Option<String>,
    /// entries property.
    pub entries: Vec<DlpEntry>,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// shared_entries property.
    pub shared_entries: Vec<DlpEntry>,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpLimits` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpLimits {
    /// max_dataset_cells property.
    pub max_dataset_cells: i64,
}

/// `DlpLimitsGetResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpLimitsGetResponse {
    /// `result` property.
    pub result: Option<DlpLimits>,
}

/// `DlpMessages` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpMessages {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpNewCustomEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewCustomEntry {
    /// description property.
    pub description: Option<String>,
    /// enabled property.
    pub enabled: bool,
    /// name property.
    pub name: String,
    /// pattern property.
    pub pattern: DlpPattern,
}

/// `DlpNewCustomEntryWithId` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewCustomEntryWithId {
    /// `entry_id` property.
    pub entry_id: String,
}

/// `DlpNewCustomProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewCustomProfile {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: Option<i64>,
    /// confidence_threshold property.
    pub confidence_threshold: Option<String>,
    /// context_awareness property.
    pub context_awareness: Option<DlpContextAwareness>,
    /// data_classes property.
    pub data_classes: Option<Vec<String>>,
    /// data_tags property.
    pub data_tags: Option<Vec<String>>,
    /// description property.
    pub description: Option<String>,
    /// entries property.
    pub entries: Option<Vec<DlpEntryOfNewProfile>>,
    /// name property.
    pub name: String,
    /// ocr_enabled property.
    pub ocr_enabled: Option<bool>,
    /// sensitivity_levels property.
    pub sensitivity_levels: Option<Vec<DlpSensitivityLevelRef>>,
    /// shared_entries property.
    pub shared_entries: Option<Vec<DlpNewSharedEntry>>,
}

/// `DlpNewEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewEntry {
    /// description property.
    pub description: Option<String>,
    /// enabled property.
    pub enabled: bool,
    /// name property.
    pub name: String,
    /// pattern property.
    pub pattern: DlpPattern,
    /// profile_id property.
    pub profile_id: Option<String>,
}

/// `DlpNewPredefinedEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewPredefinedEntry {
    /// enabled property.
    pub enabled: bool,
    /// entry_id property.
    pub entry_id: String,
    /// profile_id property.
    pub profile_id: Option<String>,
}

/// `DlpNewPredefinedProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewPredefinedProfile {
    /// `profile_id` property.
    pub profile_id: String,
}

/// `DlpNewSharedEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewSharedEntry {
    /// enabled property.
    pub enabled: bool,
    /// entry_id property.
    pub entry_id: String,
}

/// `DlpNewWordListEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpNewWordListEntry {
    /// enabled property.
    pub enabled: bool,
    /// name property.
    pub name: String,
    /// words property.
    pub words: Vec<String>,
}

/// `DlpPattern` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPattern {
    /// regex property.
    pub regex: String,
    /// validation property.
    pub validation: Option<serde_json::Value>,
}

/// `DlpPatternValidateResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPatternValidateResponse {
    /// `result` property.
    pub result: Option<DlpRegexValidationResult>,
}

/// `DlpPayloadLogSetting` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPayloadLogSetting {
    /// masking_level property.
    pub masking_level: Option<serde_json::Value>,
    /// public_key property.
    pub public_key: Option<String>,
    /// updated_at property.
    pub updated_at: String,
}

/// `DlpPredefinedEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedEntry {
    /// confidence property.
    pub confidence: DlpEntryConfidence,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// profile_id property.
    pub profile_id: Option<String>,
    /// variant property.
    pub variant: Option<serde_json::Value>,
}

/// `DlpPredefinedEntryUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedEntryUpdate {
    /// enabled property.
    pub enabled: bool,
}

/// `DlpPredefinedProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedProfile {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: i64,
    /// confidence_threshold property.
    pub confidence_threshold: Option<serde_json::Value>,
    /// context_awareness property.
    pub context_awareness: Option<DlpContextAwareness>,
    /// entries property.
    pub entries: Vec<DlpEntry>,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// ocr_enabled property.
    pub ocr_enabled: Option<bool>,
    /// open_access property.
    pub open_access: Option<bool>,
}

/// `DlpPredefinedProfileConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedProfileConfig {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: i64,
    /// confidence_threshold property.
    pub confidence_threshold: Option<String>,
    /// enabled_entries property.
    pub enabled_entries: Vec<String>,
    /// entries property.
    pub entries: Vec<DlpEntry>,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// ocr_enabled property.
    pub ocr_enabled: Option<bool>,
    /// open_access property.
    pub open_access: Option<bool>,
}

/// `DlpPredefinedProfileConfigUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedProfileConfigUpdate {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: Option<i64>,
    /// confidence_threshold property.
    pub confidence_threshold: Option<String>,
    /// enabled_entries property.
    pub enabled_entries: Option<Vec<String>>,
    /// entries property.
    pub entries: Option<Vec<DlpPredefinedProfileEntryUpdate>>,
    /// ocr_enabled property.
    pub ocr_enabled: Option<bool>,
}

/// `DlpPredefinedProfileEntryUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedProfileEntryUpdate {
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
}

/// `DlpPredefinedProfileUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpPredefinedProfileUpdate {
    /// ai_context_enabled property.
    pub ai_context_enabled: Option<bool>,
    /// allowed_match_count property.
    pub allowed_match_count: Option<i64>,
    /// confidence_threshold property.
    pub confidence_threshold: Option<String>,
    /// context_awareness property.
    pub context_awareness: Option<DlpContextAwareness>,
    /// entries property.
    pub entries: Option<Vec<DlpPredefinedProfileEntryUpdate>>,
    /// ocr_enabled property.
    pub ocr_enabled: Option<bool>,
}

/// `DlpProfile` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfile {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpProfileArray` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfileArray {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpProfileEntryUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfileEntryUpdate {
    #[serde(flatten)]
    pub data: std::collections::HashMap<String, serde_json::Value>,
}

/// `DlpProfilesCreateCustomProfilesResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesCreateCustomProfilesResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpProfilesCreatePredefinedProfileConfigResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesCreatePredefinedProfileConfigResponse {
    /// `result` property.
    pub result: Option<DlpPredefinedProfileConfig>,
}

/// `DlpProfilesCreatePredefinedProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesCreatePredefinedProfileResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpProfilesDeleteCustomProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesDeleteCustomProfileResponse {
    /// `result` property.
    pub result: Option<DlpEmpty>,
}

/// `DlpProfilesDeletePredefinedProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesDeletePredefinedProfileResponse {
    /// `result` property.
    pub result: Option<DlpEmpty>,
}

/// `DlpProfilesGetCustomProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesGetCustomProfileResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpProfilesGetDlpProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesGetDlpProfileResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpProfilesGetPredefinedProfileConfigResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesGetPredefinedProfileConfigResponse {
    /// `result` property.
    pub result: Option<DlpPredefinedProfileConfig>,
}

/// `DlpProfilesGetPredefinedProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesGetPredefinedProfileResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpProfilesListAllCustomProfilesResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesListAllCustomProfilesResponse {
    /// `result` property.
    pub result: Option<Vec<DlpCustomProfile>>,
}

/// `DlpProfilesListAllProfilesResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesListAllProfilesResponse {
    /// `result` property.
    pub result: Option<Vec<DlpProfile>>,
}

/// `DlpProfilesUpdateCustomProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesUpdateCustomProfileResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpProfilesUpdatePredefinedProfileConfigResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesUpdatePredefinedProfileConfigResponse {
    /// `result` property.
    pub result: Option<DlpPredefinedProfileConfig>,
}

/// `DlpProfilesUpdatePredefinedProfileResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpProfilesUpdatePredefinedProfileResponse {
    /// `result` property.
    pub result: Option<DlpProfile>,
}

/// `DlpRegexValidationQuery` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpRegexValidationQuery {
    /// max_match_bytes property.
    pub max_match_bytes: Option<i64>,
    /// regex property.
    pub regex: String,
}

/// `DlpRegexValidationResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpRegexValidationResult {
    /// valid property.
    pub valid: bool,
}

/// `DlpSensitivityLevelRef` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSensitivityLevelRef {
    /// group_id property.
    pub group_id: String,
    /// level_id property.
    pub level_id: String,
}

/// `DlpSettingsDeleteResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSettingsDeleteResponse {
    /// `result` property.
    pub result: Option<DlpDlpSettings>,
}

/// `DlpSettingsEditResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSettingsEditResponse {
    /// `result` property.
    pub result: Option<DlpDlpSettings>,
}

/// `DlpSettingsGetResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSettingsGetResponse {
    /// `result` property.
    pub result: Option<DlpDlpSettings>,
}

/// `DlpSettingsUpdateResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSettingsUpdateResponse {
    /// `result` property.
    pub result: Option<DlpDlpSettings>,
}

/// `DlpSharedEntryUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSharedEntryUpdate {
    /// enabled property.
    pub enabled: bool,
    /// entry_id property.
    pub entry_id: String,
}

/// `DlpSkipConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpSkipConfig {
    /// files property.
    pub files: bool,
}

/// `DlpWordListEntry` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DlpWordListEntry {
    /// created_at property.
    pub created_at: String,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// name property.
    pub name: String,
    /// profile_id property.
    pub profile_id: Option<String>,
    /// updated_at property.
    pub updated_at: String,
    /// word_list property.
    pub word_list: serde_json::Value,
}

// =============================================================================
// ARGS TYPES (per-endpoint)
// =============================================================================

/// Arguments for [`dlp-datasets-read-all_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsReadAllArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-datasets-create_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsCreateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpDatasetsCreateRequest,
}

/// Arguments for [`dlp-datasets-read_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsReadArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
}

/// Arguments for [`dlp-datasets-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
    /// Request body.
    pub body: DlpDatasetsUpdateRequest,
}

/// Arguments for [`dlp-datasets-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
}

/// Arguments for [`dlp-datasets-create-version_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsCreateVersionArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
}

/// Arguments for [`dlp-datasets-upload-version_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsUploadVersionArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
    /// Path parameter: `version`.
    pub version: String,
}

/// Arguments for [`dlp-datasets-define-columns_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsDefineColumnsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
    /// Path parameter: `version`.
    pub version: String,
    /// Request body.
    pub body: Vec<DlpDatasetsDefineColumnsRequestItem>,
}

/// Arguments for [`dlp-datasets-upload-dataset-column_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpDatasetsUploadDatasetColumnArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `dataset_id`.
    pub dataset_id: String,
    /// Path parameter: `version`.
    pub version: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
}

/// Arguments for [`dlp-entries-list-all-entries_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesListAllEntriesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-entries-create-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesCreateEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpNewEntry,
}

/// Arguments for [`dlp-entries-update-custom-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesUpdateCustomEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
    /// Request body.
    pub body: DlpCustomEntryUpdate,
}

/// Arguments for [`dlp-entries-create-integration-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesCreateIntegrationEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpNewPredefinedEntry,
}

/// Arguments for [`dlp-entries-update-integration-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesUpdateIntegrationEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
    /// Request body.
    pub body: DlpPredefinedEntryUpdate,
}

/// Arguments for [`dlp-entries-delete-integration-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesDeleteIntegrationEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
}

/// Arguments for [`dlp-entries-create-predefined-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesCreatePredefinedEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpNewPredefinedEntry,
}

/// Arguments for [`dlp-entries-update-predefined-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesUpdatePredefinedEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
    /// Request body.
    pub body: DlpPredefinedEntryUpdate,
}

/// Arguments for [`dlp-entries-delete-predefined-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesDeletePredefinedEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
}

/// Arguments for [`dlp-entries-get-dlp-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesGetDlpEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
}

/// Arguments for [`dlp-entries-update-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesUpdateEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
    /// Request body.
    pub body: DlpEntryUpdate,
}

/// Arguments for [`dlp-entries-delete-entry_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpEntriesDeleteEntryArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `entry_id`.
    pub entry_id: String,
}

/// Arguments for [`dlp-limits-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpLimitsGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-pattern-validate_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpPatternValidateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpRegexValidationQuery,
}

/// Arguments for [`dlp-profiles-list-all-profiles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesListAllProfilesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `all`.
    pub all: Option<String>,
}

/// Arguments for [`dlp-profiles-list-all-custom-profiles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesListAllCustomProfilesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-profiles-create-custom-profiles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesCreateCustomProfilesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpNewCustomProfile,
}

/// Arguments for [`dlp-profiles-get-custom-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesGetCustomProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
}

/// Arguments for [`dlp-profiles-update-custom-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesUpdateCustomProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
    /// Request body.
    pub body: DlpCustomProfileUpdate,
}

/// Arguments for [`dlp-profiles-delete-custom-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesDeleteCustomProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
}

/// Arguments for [`dlp-profiles-create-predefined-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesCreatePredefinedProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpNewPredefinedProfile,
}

/// Arguments for [`dlp-profiles-get-predefined-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesGetPredefinedProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
}

/// Arguments for [`dlp-profiles-update-predefined-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesUpdatePredefinedProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
    /// Request body.
    pub body: DlpPredefinedProfileUpdate,
}

/// Arguments for [`dlp-profiles-delete-predefined-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesDeletePredefinedProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
}

/// Arguments for [`dlp-profiles-get-predefined-profile-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesGetPredefinedProfileConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
}

/// Arguments for [`dlp-profiles-create-predefined-profile-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesCreatePredefinedProfileConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
    /// Request body.
    pub body: DlpPredefinedProfileConfigUpdate,
}

/// Arguments for [`dlp-profiles-update-predefined-profile-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesUpdatePredefinedProfileConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
    /// Request body.
    pub body: DlpPredefinedProfileConfigUpdate,
}

/// Arguments for [`dlp-profiles-get-dlp-profile_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpProfilesGetDlpProfileArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `profile_id`.
    pub profile_id: String,
}

/// Arguments for [`dlp-settings-get_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpSettingsGetArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`dlp-settings-update_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpSettingsUpdateArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpDlpSettingsUpdate,
}

/// Arguments for [`dlp-settings-edit_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpSettingsEditArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: DlpDlpSettingsUpdate,
}

/// Arguments for [`dlp-settings-delete_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DlpSettingsDeleteArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

// =============================================================================
// CLIENT FUNCTIONS (per-endpoint)
// =============================================================================

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/datasets
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/datasets.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_read_all_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_read_all_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsReadAllArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsReadAllResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets",
        args.account_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsReadAllResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/datasets
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/datasets.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_create_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_create_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsCreateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsCreateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsCreateResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/datasets/{dataset_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/datasets/{dataset_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_read_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_read_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsReadArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsReadResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}",
        args.account_id,
        args.dataset_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsReadResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/datasets/{dataset_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/datasets/{dataset_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_update_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsUpdateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}",
        args.account_id,
        args.dataset_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsUpdateResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/datasets/{dataset_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/datasets/{dataset_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_delete_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}",
        args.account_id,
        args.dataset_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    Ok(ApiResponse { status: status as u16, headers, body: () })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/upload
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/upload.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_create_version_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_create_version_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsCreateVersionArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsCreateVersionResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}/upload",
        args.account_id,
        args.dataset_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsCreateVersionResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/upload/{version}
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/upload/{version}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_upload_version_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_upload_version_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsUploadVersionArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsUploadVersionResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}/upload/{}",
        args.account_id,
        args.dataset_id,
        args.version,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsUploadVersionResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/versions/{version}
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/versions/{version}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_define_columns_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_define_columns_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsDefineColumnsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsDefineColumnsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}/versions/{}",
        args.account_id,
        args.dataset_id,
        args.version,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsDefineColumnsResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/versions/{version}/entries/{entry_id}
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/datasets/{dataset_id}/versions/{version}/entries/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_datasets_upload_dataset_column_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_datasets_upload_dataset_column_request<F>(
    client: DynNetClient,
    args: &DlpDatasetsUploadDatasetColumnArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpDatasetsUploadDatasetColumnResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/datasets/{}/versions/{}/entries/{}",
        args.account_id,
        args.dataset_id,
        args.version,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::post(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpDatasetsUploadDatasetColumnResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/entries
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/entries.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_list_all_entries_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_list_all_entries_request<F>(
    client: DynNetClient,
    args: &DlpEntriesListAllEntriesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesListAllEntriesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries",
        args.account_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesListAllEntriesResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/entries
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/entries.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_create_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_create_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesCreateEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesCreateEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesCreateEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/entries/custom/{entry_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/entries/custom/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_update_custom_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_update_custom_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesUpdateCustomEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesUpdateCustomEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/custom/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesUpdateCustomEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/entries/integration
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/entries/integration.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_create_integration_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_create_integration_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesCreateIntegrationEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesCreateIntegrationEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/integration",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesCreateIntegrationEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/entries/integration/{entry_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/entries/integration/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_update_integration_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_update_integration_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesUpdateIntegrationEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesUpdateIntegrationEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/integration/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesUpdateIntegrationEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/entries/integration/{entry_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/entries/integration/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_delete_integration_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_delete_integration_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesDeleteIntegrationEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesDeleteIntegrationEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/integration/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesDeleteIntegrationEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/entries/predefined
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/entries/predefined.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_create_predefined_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_create_predefined_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesCreatePredefinedEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesCreatePredefinedEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/predefined",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesCreatePredefinedEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/entries/predefined/{entry_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/entries/predefined/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_update_predefined_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_update_predefined_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesUpdatePredefinedEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesUpdatePredefinedEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/predefined/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesUpdatePredefinedEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/entries/predefined/{entry_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/entries/predefined/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_delete_predefined_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_delete_predefined_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesDeletePredefinedEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesDeletePredefinedEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/predefined/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesDeletePredefinedEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/entries/{entry_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/entries/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_get_dlp_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_get_dlp_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesGetDlpEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesGetDlpEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/{}",
        args.account_id,
        args.entry_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesGetDlpEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/entries/{entry_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/entries/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_update_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_update_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesUpdateEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesUpdateEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesUpdateEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/entries/{entry_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/entries/{entry_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_entries_delete_entry_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_entries_delete_entry_request<F>(
    client: DynNetClient,
    args: &DlpEntriesDeleteEntryArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpEntriesDeleteEntryResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/entries/{}",
        args.account_id,
        args.entry_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpEntriesDeleteEntryResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/limits
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/limits.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_limits_get_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_limits_get_request<F>(
    client: DynNetClient,
    args: &DlpLimitsGetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpLimitsGetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/limits",
        args.account_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpLimitsGetResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/patterns/validate
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/patterns/validate.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_pattern_validate_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_pattern_validate_request<F>(
    client: DynNetClient,
    args: &DlpPatternValidateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpPatternValidateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/patterns/validate",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpPatternValidateResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/profiles
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/profiles.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_list_all_profiles_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_list_all_profiles_request<F>(
    client: DynNetClient,
    args: &DlpProfilesListAllProfilesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesListAllProfilesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles",
        args.account_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("all", args.all.as_deref());

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesListAllProfilesResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/profiles/custom
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/profiles/custom.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_list_all_custom_profiles_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_list_all_custom_profiles_request<F>(
    client: DynNetClient,
    args: &DlpProfilesListAllCustomProfilesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesListAllCustomProfilesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/custom",
        args.account_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesListAllCustomProfilesResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/profiles/custom
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/profiles/custom.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_create_custom_profiles_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_create_custom_profiles_request<F>(
    client: DynNetClient,
    args: &DlpProfilesCreateCustomProfilesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesCreateCustomProfilesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/custom",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesCreateCustomProfilesResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/profiles/custom/{profile_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/profiles/custom/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_get_custom_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_get_custom_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesGetCustomProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesGetCustomProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/custom/{}",
        args.account_id,
        args.profile_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesGetCustomProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/profiles/custom/{profile_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/profiles/custom/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_update_custom_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_update_custom_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesUpdateCustomProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesUpdateCustomProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/custom/{}",
        args.account_id,
        args.profile_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesUpdateCustomProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/profiles/custom/{profile_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/profiles/custom/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_delete_custom_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_delete_custom_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesDeleteCustomProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesDeleteCustomProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/custom/{}",
        args.account_id,
        args.profile_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesDeleteCustomProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/profiles/predefined
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/profiles/predefined.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_create_predefined_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_create_predefined_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesCreatePredefinedProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesCreatePredefinedProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined",
        args.account_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesCreatePredefinedProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/profiles/predefined/{profile_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/profiles/predefined/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_get_predefined_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_get_predefined_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesGetPredefinedProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesGetPredefinedProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined/{}",
        args.account_id,
        args.profile_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesGetPredefinedProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/profiles/predefined/{profile_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/profiles/predefined/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_update_predefined_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_update_predefined_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesUpdatePredefinedProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesUpdatePredefinedProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined/{}",
        args.account_id,
        args.profile_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesUpdatePredefinedProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/profiles/predefined/{profile_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/profiles/predefined/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_delete_predefined_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_delete_predefined_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesDeletePredefinedProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesDeletePredefinedProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined/{}",
        args.account_id,
        args.profile_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesDeletePredefinedProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/profiles/predefined/{profile_id}/config
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/profiles/predefined/{profile_id}/config.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_get_predefined_profile_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_get_predefined_profile_config_request<F>(
    client: DynNetClient,
    args: &DlpProfilesGetPredefinedProfileConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesGetPredefinedProfileConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined/{}/config",
        args.account_id,
        args.profile_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesGetPredefinedProfileConfigResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/dlp/profiles/predefined/{profile_id}/config
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/dlp/profiles/predefined/{profile_id}/config.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_create_predefined_profile_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_create_predefined_profile_config_request<F>(
    client: DynNetClient,
    args: &DlpProfilesCreatePredefinedProfileConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesCreatePredefinedProfileConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined/{}/config",
        args.account_id,
        args.profile_id,
    );
    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.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesCreatePredefinedProfileConfigResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/profiles/predefined/{profile_id}/config
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/profiles/predefined/{profile_id}/config.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_update_predefined_profile_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_update_predefined_profile_config_request<F>(
    client: DynNetClient,
    args: &DlpProfilesUpdatePredefinedProfileConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesUpdatePredefinedProfileConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/predefined/{}/config",
        args.account_id,
        args.profile_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesUpdatePredefinedProfileConfigResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/profiles/{profile_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/profiles/{profile_id}.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_profiles_get_dlp_profile_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_profiles_get_dlp_profile_request<F>(
    client: DynNetClient,
    args: &DlpProfilesGetDlpProfileArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpProfilesGetDlpProfileResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/profiles/{}",
        args.account_id,
        args.profile_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpProfilesGetDlpProfileResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/dlp/settings
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/dlp/settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_settings_get_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_settings_get_request<F>(
    client: DynNetClient,
    args: &DlpSettingsGetArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpSettingsGetResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/settings",
        args.account_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()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpSettingsGetResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/dlp/settings
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/dlp/settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_settings_update_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_settings_update_request<F>(
    client: DynNetClient,
    args: &DlpSettingsUpdateArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpSettingsUpdateResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/settings",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpSettingsUpdateResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// PATCH /accounts/{account_id}/dlp/settings
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/dlp/settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_settings_edit_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_settings_edit_request<F>(
    client: DynNetClient,
    args: &DlpSettingsEditArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpSettingsEditResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/settings",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    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);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpSettingsEditResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}

// -----------------------------------------------------------------------------
// DELETE /accounts/{account_id}/dlp/settings
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/dlp/settings.
///
/// Takes a `DynNetClient` and args, builds the request, optionally applies
/// modifications, then sends it via `send_async().await`.
///
/// # Arguments
///
/// * `client` - HTTP client for making the request
/// * `args` - Request arguments (path params, query params, body)
/// * `builder_mod` - Optional closure to modify the request builder (e.g., add headers)
///
/// # Example
///
/// ```ignore
/// let response = dlp_settings_delete_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn dlp_settings_delete_request<F>(
    client: DynNetClient,
    args: &DlpSettingsDeleteArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<DlpSettingsDeleteResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/dlp/settings",
        args.account_id,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

    if let Some(f) = builder_mod {
        f(&mut builder);
    }

    let response = client.send_async(builder.build()).await
        .map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: DlpSettingsDeleteResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
    Ok(ApiResponse { status: status as u16, headers, body: parsed })
}