foundation_deployment_cloudflare 0.1.2

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

#![cfg(feature = "cloudflare_storage")]
#![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
// =============================================================================

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `MagicVisibilityPcapsPcapsOwnershipRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityPcapsPcapsOwnershipRequest {
    /// destination_conf property.
    pub destination_conf: MagicVisibilityPcapsPcapsDestinationConf,
}

/// `MagicVisibilityPcapsPcapsOwnershipResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityPcapsPcapsOwnershipResponse {
    /// destination_conf property.
    pub destination_conf: MagicVisibilityPcapsPcapsDestinationConf,
    /// filename property.
    pub filename: MagicVisibilityPcapsPcapsOwnershipChallenge,
    /// id property.
    pub id: String,
    /// status property.
    pub status: String,
    /// submitted property.
    pub submitted: String,
    /// validated property.
    pub validated: Option<String>,
}

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

/// `MagicVisibilityPcapsPcapsOwnershipValidateRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityPcapsPcapsOwnershipValidateRequest {
    /// destination_conf property.
    pub destination_conf: MagicVisibilityPcapsPcapsDestinationConf,
    /// ownership_challenge property.
    pub ownership_challenge: MagicVisibilityPcapsPcapsOwnershipChallenge,
}

/// `MagicVisibilityPcapsResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct MagicVisibilityPcapsResultInfo {
    /// count property.
    pub count: Option<f64>,
    /// page property.
    pub page: Option<f64>,
    /// per_page property.
    pub per_page: Option<f64>,
    /// total_count property.
    pub total_count: Option<f64>,
}

/// `R2AccountLevelMetrics` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2AccountLevelMetrics {
    /// infrequentAccess property.
    #[serde(rename = "infrequentAccess")]
    pub infrequent_access: Option<R2ClassBasedMetrics>,
    /// standard property.
    pub standard: Option<R2ClassBasedMetrics>,
}

/// `R2Bucket` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2Bucket {
    /// creation_date property.
    pub creation_date: Option<String>,
    /// jurisdiction property.
    pub jurisdiction: Option<R2Jurisdiction>,
    /// location property.
    pub location: Option<R2BucketLocation>,
    /// name property.
    pub name: Option<R2BucketName>,
    /// storage_class property.
    pub storage_class: Option<R2StorageClass>,
}

/// `R2BucketConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2BucketConfig {
    /// bucketName property.
    #[serde(rename = "bucketName")]
    pub bucket_name: Option<String>,
    /// queues property.
    pub queues: Option<Vec<R2QueuesConfig>>,
}

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

/// `R2BucketLockRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2BucketLockRule {
    /// condition property.
    pub condition: serde_json::Value,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// prefix property.
    pub prefix: Option<String>,
}

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

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

/// `R2ClassBasedMetrics` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2ClassBasedMetrics {
    /// published property.
    pub published: Option<R2ObjectSizeMetrics>,
    /// uploaded property.
    pub uploaded: Option<R2ObjectSizeMetrics>,
}

/// `R2CorsRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2CorsRule {
    /// allowed property.
    pub allowed: std::collections::HashMap<String, serde_json::Value>,
    /// exposeHeaders property.
    #[serde(rename = "exposeHeaders")]
    pub expose_headers: Option<Vec<String>>,
    /// id property.
    pub id: Option<String>,
    /// maxAgeSeconds property.
    #[serde(rename = "maxAgeSeconds")]
    pub max_age_seconds: Option<f64>,
}

/// `R2CreateBucketRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2CreateBucketRequest {
    /// locationHint property.
    #[serde(rename = "locationHint")]
    pub location_hint: Option<R2BucketLocation>,
    /// name property.
    pub name: R2BucketName,
    /// storageClass property.
    #[serde(rename = "storageClass")]
    pub storage_class: Option<R2StorageClass>,
}

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

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

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

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

/// `R2DataCatalogApiResponseSingle` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogApiResponseSingle {
    /// 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: R2DataCatalogApiResponseSuccess,
}

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

/// `R2DataCatalogCatalog` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogCatalog {
    /// bucket property.
    pub bucket: String,
    /// credential_status property.
    pub credential_status: Option<String>,
    /// id property.
    pub id: String,
    /// maintenance_config property.
    pub maintenance_config: Option<serde_json::Value>,
    /// name property.
    pub name: String,
    /// status property.
    pub status: R2DataCatalogCatalogStatus,
}

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

/// `R2DataCatalogCatalogCompactionConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogCatalogCompactionConfig {
    /// state property.
    pub state: R2DataCatalogCatalogMaintenanceState,
    /// target_size_mb property.
    pub target_size_mb: R2DataCatalogCatalogTargetFileSize,
}

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

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

/// `R2DataCatalogCatalogMaintenanceConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogCatalogMaintenanceConfig {
    /// compaction property.
    pub compaction: Option<R2DataCatalogCatalogCompactionConfig>,
    /// snapshot_expiration property.
    pub snapshot_expiration: Option<R2DataCatalogSnapshotExpirationConfig>,
}

/// `R2DataCatalogCatalogMaintenanceConfigResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogCatalogMaintenanceConfigResponse {
    /// credential_status property.
    pub credential_status: R2DataCatalogCredentialStatus,
    /// maintenance_config property.
    pub maintenance_config: R2DataCatalogCatalogMaintenanceConfig,
}

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

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

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

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

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

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

/// `R2DataCatalogMaintenanceUpdateParams` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogMaintenanceUpdateParams {
    /// compaction property.
    pub compaction: Option<R2DataCatalogCompactionUpdateParams>,
    /// snapshot_expiration property.
    pub snapshot_expiration: Option<R2DataCatalogSnapshotExpirationUpdateParams>,
}

/// `R2DataCatalogNamespaceDetails` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogNamespaceDetails {
    /// created_at property.
    pub created_at: Option<String>,
    /// namespace property.
    pub namespace: Vec<String>,
    /// namespace_uuid property.
    pub namespace_uuid: String,
    /// updated_at property.
    pub updated_at: Option<String>,
}

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

/// `R2DataCatalogNamespaceListResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogNamespaceListResponse {
    /// details property.
    pub details: Option<Vec<R2DataCatalogNamespaceDetails>>,
    /// namespace_uuids property.
    pub namespace_uuids: Option<Vec<String>>,
    /// namespaces property.
    pub namespaces: Vec<Vec<String>>,
    /// next_page_token property.
    pub next_page_token: Option<String>,
}

/// `R2DataCatalogSnapshotExpirationConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogSnapshotExpirationConfig {
    /// max_snapshot_age property.
    pub max_snapshot_age: String,
    /// min_snapshots_to_keep property.
    pub min_snapshots_to_keep: i64,
    /// state property.
    pub state: R2DataCatalogCatalogMaintenanceState,
}

/// `R2DataCatalogSnapshotExpirationUpdateParams` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogSnapshotExpirationUpdateParams {
    /// max_snapshot_age property.
    pub max_snapshot_age: Option<String>,
    /// min_snapshots_to_keep property.
    pub min_snapshots_to_keep: Option<i64>,
    /// state property.
    pub state: Option<serde_json::Value>,
}

/// `R2DataCatalogTableCompactionConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogTableCompactionConfig {
    /// state property.
    pub state: R2DataCatalogCatalogMaintenanceState,
    /// target_size_mb property.
    pub target_size_mb: R2DataCatalogCatalogTargetFileSize,
}

/// `R2DataCatalogTableDetails` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogTableDetails {
    /// created_at property.
    pub created_at: Option<String>,
    /// identifier property.
    pub identifier: R2DataCatalogTableIdentifier,
    /// location property.
    pub location: Option<String>,
    /// metadata_location property.
    pub metadata_location: Option<String>,
    /// table_uuid property.
    pub table_uuid: String,
    /// updated_at property.
    pub updated_at: Option<String>,
}

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

/// `R2DataCatalogTableListResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogTableListResponse {
    /// details property.
    pub details: Option<Vec<R2DataCatalogTableDetails>>,
    /// identifiers property.
    pub identifiers: Vec<R2DataCatalogTableIdentifier>,
    /// next_page_token property.
    pub next_page_token: Option<String>,
    /// table_uuids property.
    pub table_uuids: Option<Vec<String>>,
}

/// `R2DataCatalogTableMaintenanceConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogTableMaintenanceConfig {
    /// compaction property.
    pub compaction: Option<R2DataCatalogTableCompactionConfig>,
    /// snapshot_expiration property.
    pub snapshot_expiration: Option<R2DataCatalogSnapshotExpirationConfig>,
}

/// `R2DataCatalogTableMaintenanceConfigResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DataCatalogTableMaintenanceConfigResponse {
    /// maintenance_config property.
    pub maintenance_config: R2DataCatalogTableMaintenanceConfig,
}

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

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

/// `R2DeleteBucketSippyConfigResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2DeleteBucketSippyConfigResponse {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `R2EnableSippyAws` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2EnableSippyAws {
    /// destination property.
    pub destination: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// source property.
    pub source: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `R2EnableSippyGcs` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2EnableSippyGcs {
    /// destination property.
    pub destination: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// source property.
    pub source: Option<std::collections::HashMap<String, serde_json::Value>>,
}

/// `R2EnableSippyS3` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2EnableSippyS3 {
    /// destination property.
    pub destination: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// source property.
    pub source: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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

/// `R2EventNotificationDeleteConfigRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2EventNotificationDeleteConfigRequest {
    /// ruleIds property.
    #[serde(rename = "ruleIds")]
    pub rule_ids: Option<Vec<String>>,
}

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

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

/// `R2GetBucketCorsPolicyResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2GetBucketCorsPolicyResponse {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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

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

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

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

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

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

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

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

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

/// `R2LifecycleRule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2LifecycleRule {
    /// abortMultipartUploadsTransition property.
    #[serde(rename = "abortMultipartUploadsTransition")]
    pub abort_multipart_uploads_transition: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// conditions property.
    pub conditions: std::collections::HashMap<String, serde_json::Value>,
    /// deleteObjectsTransition property.
    #[serde(rename = "deleteObjectsTransition")]
    pub delete_objects_transition: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// enabled property.
    pub enabled: bool,
    /// id property.
    pub id: String,
    /// storageClassTransitions property.
    #[serde(rename = "storageClassTransitions")]
    pub storage_class_transitions: Option<Vec<serde_json::Value>>,
}

/// `R2LifecycleStorageTransition` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2LifecycleStorageTransition {
    /// condition property.
    pub condition: serde_json::Value,
    /// storageClass property.
    #[serde(rename = "storageClass")]
    pub storage_class: String,
}

/// `R2ListBucketsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2ListBucketsResponse {
    /// `result` property.
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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

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

/// `R2ObjectSizeMetrics` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2ObjectSizeMetrics {
    /// metadataSize property.
    #[serde(rename = "metadataSize")]
    pub metadata_size: Option<f64>,
    /// objects property.
    pub objects: Option<f64>,
    /// payloadSize property.
    #[serde(rename = "payloadSize")]
    pub payload_size: Option<f64>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `R2QueuesConfig` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2QueuesConfig {
    /// queueId property.
    #[serde(rename = "queueId")]
    pub queue_id: Option<String>,
    /// queueName property.
    #[serde(rename = "queueName")]
    pub queue_name: Option<String>,
    /// rules property.
    pub rules: Option<Vec<serde_json::Value>>,
}

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

/// `R2ResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2ResultInfo {
    /// cursor property.
    pub cursor: Option<String>,
    /// per_page property.
    pub per_page: Option<f64>,
}

/// `R2Rule` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2Rule {
    /// actions property.
    pub actions: Vec<R2R2Action>,
    /// description property.
    pub description: Option<String>,
    /// prefix property.
    pub prefix: Option<String>,
    /// suffix property.
    pub suffix: Option<String>,
}

/// `R2Sippy` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2Sippy {
    /// destination property.
    pub destination: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// enabled property.
    pub enabled: Option<bool>,
    /// source property.
    pub source: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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

/// `R2TempAccessCredsRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2TempAccessCredsRequest {
    /// bucket property.
    pub bucket: String,
    /// objects property.
    pub objects: Option<Vec<String>>,
    /// parentAccessKeyId property.
    #[serde(rename = "parentAccessKeyId")]
    pub parent_access_key_id: String,
    /// permission property.
    pub permission: String,
    /// prefixes property.
    pub prefixes: Option<Vec<String>>,
    /// ttlSeconds property.
    #[serde(rename = "ttlSeconds")]
    pub ttl_seconds: f64,
}

/// `R2TempAccessCredsResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct R2TempAccessCredsResponse {
    /// accessKeyId property.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: Option<String>,
    /// secretAccessKey property.
    #[serde(rename = "secretAccessKey")]
    pub secret_access_key: Option<String>,
    /// sessionToken property.
    #[serde(rename = "sessionToken")]
    pub session_token: Option<String>,
}

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

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

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

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

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

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

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

/// `WorkersKvApiResponseCommon` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvApiResponseCommon {
    /// 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,
}

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

/// `WorkersKvBulkResult` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvBulkResult {
    /// successful_key_count property.
    pub successful_key_count: Option<f64>,
    /// unsuccessful_keys property.
    pub unsuccessful_keys: Option<Vec<String>>,
}

/// `WorkersKvCreateRenameNamespaceBody` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvCreateRenameNamespaceBody {
    /// title property.
    pub title: WorkersKvNamespaceTitle,
}

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

/// `WorkersKvCursorResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvCursorResultInfo {
    /// count property.
    pub count: Option<f64>,
    /// cursor property.
    pub cursor: Option<WorkersKvCursor>,
}

/// `WorkersKvKey` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvKey {
    /// expiration property.
    pub expiration: Option<f64>,
    /// metadata property.
    pub metadata: Option<WorkersKvListMetadata>,
    /// name property.
    pub name: WorkersKvKeyName,
}

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

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

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

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

/// `WorkersKvNamespace` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvNamespace {
    /// id property.
    pub id: WorkersKvNamespaceIdentifier,
    /// supports_url_encoding property.
    pub supports_url_encoding: Option<bool>,
    /// title property.
    pub title: WorkersKvNamespaceTitle,
}

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

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

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

/// `WorkersKvNamespaceGetMultipleKeyValuePairsRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvNamespaceGetMultipleKeyValuePairsRequest {
    /// keys property.
    pub keys: Vec<WorkersKvKeyNameBulk>,
    /// type property.
    #[serde(rename = "type")]
    pub r#type: Option<String>,
    /// withMetadata property.
    #[serde(rename = "withMetadata")]
    pub with_metadata: Option<bool>,
}

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

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

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

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

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

/// `WorkersKvNamespaceRenameANamespaceResponse` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvNamespaceRenameANamespaceResponse {
    /// `result` property.
    pub result: WorkersKvNamespace,
}

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

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

/// `WorkersKvResultInfo` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct WorkersKvResultInfo {
    /// count property.
    pub count: Option<f64>,
    /// page property.
    pub page: Option<f64>,
    /// per_page property.
    pub per_page: Option<f64>,
    /// total_count property.
    pub total_count: Option<f64>,
}

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

/// Arguments for [`r2-get-event-notification-configs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetEventNotificationConfigsArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-get-event-notification-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetEventNotificationConfigArgs {
    /// Path parameter: `queue_id`.
    pub queue_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-put-event-notification-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PutEventNotificationConfigArgs {
    /// Path parameter: `queue_id`.
    pub queue_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2PutEventNotificationConfigRequest,
}

/// Arguments for [`r2-event-notification-delete-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2EventNotificationDeleteConfigArgs {
    /// Path parameter: `queue_id`.
    pub queue_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2EventNotificationDeleteConfigRequest,
}

/// Arguments for [`magic-pcap-collection-list-pca-ps-bucket-ownership_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicPcapCollectionListPcaPsBucketOwnershipArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`magic-pcap-collection-add-buckets-for-full-packet-captures_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicPcapCollectionAddBucketsForFullPacketCapturesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicVisibilityPcapsPcapsOwnershipRequest,
}

/// Arguments for [`magic-pcap-collection-validate-buckets-for-full-packet-captures_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicPcapCollectionValidateBucketsForFullPacketCapturesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: MagicVisibilityPcapsPcapsOwnershipValidateRequest,
}

/// Arguments for [`magic-pcap-collection-delete-buckets-for-full-packet-captures_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct MagicPcapCollectionDeleteBucketsForFullPacketCapturesArgs {
    /// Path parameter: `ownership_id`.
    pub ownership_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

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

/// Arguments for [`get-catalog-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetCatalogDetailsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`store-credentials_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StoreCredentialsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Request body.
    pub body: R2DataCatalogCatalogCredentialRequest,
}

/// Arguments for [`disable-catalog_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DisableCatalogArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`enable-catalog_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EnableCatalogArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`get-maintenance-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetMaintenanceConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`update-maintenance-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateMaintenanceConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Request body.
    pub body: R2DataCatalogCatalogMaintenanceUpdateRequest,
}

/// Arguments for [`list-namespaces_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListNamespacesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Query parameter: `page_token`.
    pub page_token: Option<String>,
    /// Query parameter: `page_size`.
    pub page_size: Option<String>,
    /// Query parameter: `parent`.
    pub parent: Option<String>,
    /// Query parameter: `return_uuids`.
    pub return_uuids: Option<String>,
    /// Query parameter: `return_details`.
    pub return_details: Option<String>,
}

/// Arguments for [`list-tables_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListTablesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `namespace`.
    pub namespace: String,
    /// Query parameter: `page_token`.
    pub page_token: Option<String>,
    /// Query parameter: `page_size`.
    pub page_size: Option<String>,
    /// Query parameter: `return_uuids`.
    pub return_uuids: Option<String>,
    /// Query parameter: `return_details`.
    pub return_details: Option<String>,
}

/// Arguments for [`get-table-maintenance-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetTableMaintenanceConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `namespace`.
    pub namespace: String,
    /// Path parameter: `table_name`.
    pub table_name: String,
}

/// Arguments for [`update-table-maintenance-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct UpdateTableMaintenanceConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `namespace`.
    pub namespace: String,
    /// Path parameter: `table_name`.
    pub table_name: String,
    /// Request body.
    pub body: R2DataCatalogTableMaintenanceUpdateRequest,
}

/// Arguments for [`r2-list-buckets_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2ListBucketsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `name_contains`.
    pub name_contains: Option<String>,
    /// Query parameter: `start_after`.
    pub start_after: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
}

/// Arguments for [`r2-create-bucket_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2CreateBucketArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2CreateBucketRequest,
}

/// Arguments for [`r2-get-bucket_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetBucketArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`r2-patch-bucket_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PatchBucketArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`r2-delete-bucket_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2DeleteBucketArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-get-bucket-cors-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetBucketCorsPolicyArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-put-bucket-cors-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PutBucketCorsPolicyArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2PutBucketCorsPolicyRequest,
}

/// Arguments for [`r2-delete-bucket-cors-policy_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2DeleteBucketCorsPolicyArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-get-bucket-lifecycle-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetBucketLifecycleConfigurationArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-put-bucket-lifecycle-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PutBucketLifecycleConfigurationArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2PutBucketLifecycleConfigurationRequest,
}

/// Arguments for [`r2-get-bucket-local-uploads-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetBucketLocalUploadsConfigurationArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-put-bucket-local-uploads-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PutBucketLocalUploadsConfigurationArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2PutBucketLocalUploadsConfigurationRequest,
}

/// Arguments for [`r2-get-bucket-lock-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetBucketLockConfigurationArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-put-bucket-lock-configuration_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PutBucketLockConfigurationArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2PutBucketLockConfigurationRequest,
}

/// Arguments for [`r2-get-bucket-sippy-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetBucketSippyConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
}

/// Arguments for [`r2-put-bucket-sippy-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2PutBucketSippyConfigArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Request body.
    pub body: R2PutBucketSippyConfigRequest,
}

/// Arguments for [`r2-delete-bucket-sippy-config_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2DeleteBucketSippyConfigArgs {
    /// Path parameter: `bucket_name`.
    pub bucket_name: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-get-account-level-metrics_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2GetAccountLevelMetricsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`r2-create-temp-access-credentials_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct R2CreateTempAccessCredentialsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: R2TempAccessCredsRequest,
}

/// Arguments for [`workers-kv-namespace-list-namespaces_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceListNamespacesArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `page`.
    pub page: Option<String>,
    /// Query parameter: `per_page`.
    pub per_page: Option<String>,
    /// Query parameter: `order`.
    pub order: Option<String>,
    /// Query parameter: `direction`.
    pub direction: Option<String>,
}

/// Arguments for [`workers-kv-namespace-create-a-namespace_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceCreateANamespaceArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: WorkersKvCreateRenameNamespaceBody,
}

/// Arguments for [`workers-kv-namespace-get-a-namespace_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceGetANamespaceArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`workers-kv-namespace-rename-a-namespace_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceRenameANamespaceArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: WorkersKvCreateRenameNamespaceBody,
}

/// Arguments for [`workers-kv-namespace-remove-a-namespace_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceRemoveANamespaceArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`workers-kv-namespace-write-multiple-key-value-pairs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceWriteMultipleKeyValuePairsArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: Vec<serde_json::Value>,
}

/// Arguments for [`workers-kv-namespace-delete-multiple-key-value-pairs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceDeleteMultipleKeyValuePairsArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`workers-kv-namespace-get-multiple-key-value-pairs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceGetMultipleKeyValuePairsArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: WorkersKvNamespaceGetMultipleKeyValuePairsRequest,
}

/// Arguments for [`workers-kv-namespace-list-a-namespace'-s-keys_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceListANamespaceSKeysArgs {
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `limit`.
    pub limit: Option<String>,
    /// Query parameter: `prefix`.
    pub prefix: Option<String>,
    /// Query parameter: `cursor`.
    pub cursor: Option<String>,
}

/// Arguments for [`workers-kv-namespace-read-the-metadata-for-a-key_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceReadTheMetadataForAKeyArgs {
    /// Path parameter: `key_name`.
    pub key_name: String,
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`workers-kv-namespace-read-key-value-pair_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceReadKeyValuePairArgs {
    /// Path parameter: `key_name`.
    pub key_name: String,
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`workers-kv-namespace-write-key-value-pair-with-metadata_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceWriteKeyValuePairWithMetadataArgs {
    /// Path parameter: `key_name`.
    pub key_name: String,
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `expiration`.
    pub expiration: Option<String>,
    /// Query parameter: `expiration_ttl`.
    pub expiration_ttl: Option<String>,
}

/// Arguments for [`workers-kv-namespace-delete-key-value-pair_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct WorkersKvNamespaceDeleteKeyValuePairArgs {
    /// Path parameter: `key_name`.
    pub key_name: String,
    /// Path parameter: `namespace_id`.
    pub namespace_id: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/event_notifications/r2/{bucket_name}/configuration
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/event_notifications/r2/{bucket_name}/configuration.
///
/// 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 = r2_get_event_notification_configs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_event_notification_configs_request<F>(
    client: DynNetClient,
    args: &R2GetEventNotificationConfigsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetEventNotificationConfigsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/event_notifications/r2/{}/configuration",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetEventNotificationConfigsResponse = 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}/event_notifications/r2/{bucket_name}/configuration/queues/{queue_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/event_notifications/r2/{bucket_name}/configuration/queues/{queue_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 = r2_get_event_notification_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_event_notification_config_request<F>(
    client: DynNetClient,
    args: &R2GetEventNotificationConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetEventNotificationConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/event_notifications/r2/{}/configuration/queues/{}",
        args.account_id,
        args.bucket_name,
        args.queue_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: R2GetEventNotificationConfigResponse = 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}/event_notifications/r2/{bucket_name}/configuration/queues/{queue_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/event_notifications/r2/{bucket_name}/configuration/queues/{queue_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 = r2_put_event_notification_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_put_event_notification_config_request<F>(
    client: DynNetClient,
    args: &R2PutEventNotificationConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PutEventNotificationConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/event_notifications/r2/{}/configuration/queues/{}",
        args.account_id,
        args.bucket_name,
        args.queue_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: R2PutEventNotificationConfigResponse = 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}/event_notifications/r2/{bucket_name}/configuration/queues/{queue_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/event_notifications/r2/{bucket_name}/configuration/queues/{queue_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 = r2_event_notification_delete_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_event_notification_delete_config_request<F>(
    client: DynNetClient,
    args: &R2EventNotificationDeleteConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2EventNotificationDeleteConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/event_notifications/r2/{}/configuration/queues/{}",
        args.account_id,
        args.bucket_name,
        args.queue_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()))?;

    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: R2EventNotificationDeleteConfigResponse = 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}/pcaps/ownership
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/pcaps/ownership.
///
/// 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 = magic_pcap_collection_list_pca_ps_bucket_ownership_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_pcap_collection_list_pca_ps_bucket_ownership_request<F>(
    client: DynNetClient,
    args: &MagicPcapCollectionListPcaPsBucketOwnershipArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityPcapsPcapsOwnershipCollection>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/pcaps/ownership",
        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: MagicVisibilityPcapsPcapsOwnershipCollection = 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}/pcaps/ownership
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/pcaps/ownership.
///
/// 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 = magic_pcap_collection_add_buckets_for_full_packet_captures_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_pcap_collection_add_buckets_for_full_packet_captures_request<F>(
    client: DynNetClient,
    args: &MagicPcapCollectionAddBucketsForFullPacketCapturesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityPcapsPcapsOwnershipSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/pcaps/ownership",
        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: MagicVisibilityPcapsPcapsOwnershipSingleResponse = 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}/pcaps/ownership/validate
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/pcaps/ownership/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 = magic_pcap_collection_validate_buckets_for_full_packet_captures_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_pcap_collection_validate_buckets_for_full_packet_captures_request<F>(
    client: DynNetClient,
    args: &MagicPcapCollectionValidateBucketsForFullPacketCapturesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<MagicVisibilityPcapsPcapsOwnershipSingleResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/pcaps/ownership/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: MagicVisibilityPcapsPcapsOwnershipSingleResponse = 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}/pcaps/ownership/{ownership_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/pcaps/ownership/{ownership_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 = magic_pcap_collection_delete_buckets_for_full_packet_captures_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn magic_pcap_collection_delete_buckets_for_full_packet_captures_request<F>(
    client: DynNetClient,
    args: &MagicPcapCollectionDeleteBucketsForFullPacketCapturesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/pcaps/ownership/{}",
        args.account_id,
        args.ownership_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: () })
}

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/r2-catalog
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2-catalog.
///
/// 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 = list_catalogs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_catalogs_request<F>(
    client: DynNetClient,
    args: &ListCatalogsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListCatalogsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog",
        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: ListCatalogsResponse = 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}/r2-catalog/{bucket_name}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2-catalog/{bucket_name}.
///
/// 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 = get_catalog_details_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_catalog_details_request<F>(
    client: DynNetClient,
    args: &GetCatalogDetailsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<GetCatalogDetailsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}",
        args.account_id,
        args.bucket_name,
    );
    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: GetCatalogDetailsResponse = 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}/r2-catalog/{bucket_name}/credential
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2-catalog/{bucket_name}/credential.
///
/// 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 = store_credentials_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn store_credentials_request<F>(
    client: DynNetClient,
    args: &StoreCredentialsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<StoreCredentialsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/credential",
        args.account_id,
        args.bucket_name,
    );
    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: StoreCredentialsResponse = 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}/r2-catalog/{bucket_name}/disable
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2-catalog/{bucket_name}/disable.
///
/// 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 = disable_catalog_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn disable_catalog_request<F>(
    client: DynNetClient,
    args: &DisableCatalogArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/disable",
        args.account_id,
        args.bucket_name,
    );
    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 });
    }
    Ok(ApiResponse { status: status as u16, headers, body: () })
}

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/r2-catalog/{bucket_name}/enable
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2-catalog/{bucket_name}/enable.
///
/// 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 = enable_catalog_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn enable_catalog_request<F>(
    client: DynNetClient,
    args: &EnableCatalogArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<EnableCatalogResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/enable",
        args.account_id,
        args.bucket_name,
    );
    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: EnableCatalogResponse = 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}/r2-catalog/{bucket_name}/maintenance-configs
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2-catalog/{bucket_name}/maintenance-configs.
///
/// 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 = get_maintenance_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_maintenance_config_request<F>(
    client: DynNetClient,
    args: &GetMaintenanceConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<GetMaintenanceConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/maintenance-configs",
        args.account_id,
        args.bucket_name,
    );
    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: GetMaintenanceConfigResponse = 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}/r2-catalog/{bucket_name}/maintenance-configs
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2-catalog/{bucket_name}/maintenance-configs.
///
/// 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 = update_maintenance_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_maintenance_config_request<F>(
    client: DynNetClient,
    args: &UpdateMaintenanceConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<UpdateMaintenanceConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/maintenance-configs",
        args.account_id,
        args.bucket_name,
    );
    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: UpdateMaintenanceConfigResponse = 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}/r2-catalog/{bucket_name}/namespaces
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2-catalog/{bucket_name}/namespaces.
///
/// 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 = list_namespaces_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_namespaces_request<F>(
    client: DynNetClient,
    args: &ListNamespacesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListNamespacesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/namespaces",
        args.account_id,
        args.bucket_name,
    );
    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("page_token", args.page_token.as_deref());
    builder = builder.query("page_size", args.page_size.as_deref());
    builder = builder.query("parent", args.parent.as_deref());
    builder = builder.query("return_uuids", args.return_uuids.as_deref());
    builder = builder.query("return_details", args.return_details.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: ListNamespacesResponse = 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}/r2-catalog/{bucket_name}/namespaces/{namespace}/tables
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2-catalog/{bucket_name}/namespaces/{namespace}/tables.
///
/// 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 = list_tables_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn list_tables_request<F>(
    client: DynNetClient,
    args: &ListTablesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<ListTablesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/namespaces/{}/tables",
        args.account_id,
        args.bucket_name,
        args.namespace,
    );
    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("page_token", args.page_token.as_deref());
    builder = builder.query("page_size", args.page_size.as_deref());
    builder = builder.query("return_uuids", args.return_uuids.as_deref());
    builder = builder.query("return_details", args.return_details.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: ListTablesResponse = 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}/r2-catalog/{bucket_name}/namespaces/{namespace}/tables/{table_name}/maintenance-configs
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2-catalog/{bucket_name}/namespaces/{namespace}/tables/{table_name}/maintenance-configs.
///
/// 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 = get_table_maintenance_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn get_table_maintenance_config_request<F>(
    client: DynNetClient,
    args: &GetTableMaintenanceConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<GetTableMaintenanceConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/namespaces/{}/tables/{}/maintenance-configs",
        args.account_id,
        args.bucket_name,
        args.namespace,
        args.table_name,
    );
    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: GetTableMaintenanceConfigResponse = 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}/r2-catalog/{bucket_name}/namespaces/{namespace}/tables/{table_name}/maintenance-configs
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2-catalog/{bucket_name}/namespaces/{namespace}/tables/{table_name}/maintenance-configs.
///
/// 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 = update_table_maintenance_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn update_table_maintenance_config_request<F>(
    client: DynNetClient,
    args: &UpdateTableMaintenanceConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<UpdateTableMaintenanceConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2-catalog/{}/namespaces/{}/tables/{}/maintenance-configs",
        args.account_id,
        args.bucket_name,
        args.namespace,
        args.table_name,
    );
    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: UpdateTableMaintenanceConfigResponse = 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}/r2/buckets
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets.
///
/// 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 = r2_list_buckets_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_list_buckets_request<F>(
    client: DynNetClient,
    args: &R2ListBucketsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2ListBucketsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets",
        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("name_contains", args.name_contains.as_deref());
    builder = builder.query("start_after", args.start_after.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.as_deref());
    builder = builder.query("cursor", args.cursor.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: R2ListBucketsResponse = 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}/r2/buckets
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2/buckets.
///
/// 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 = r2_create_bucket_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_create_bucket_request<F>(
    client: DynNetClient,
    args: &R2CreateBucketArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2CreateBucketResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets",
        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: R2CreateBucketResponse = 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}/r2/buckets/{bucket_name}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets/{bucket_name}.
///
/// 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 = r2_get_bucket_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_bucket_request<F>(
    client: DynNetClient,
    args: &R2GetBucketArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetBucketResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetBucketResponse = 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}/r2/buckets/{bucket_name}
// -----------------------------------------------------------------------------

/// PATCH /accounts/{account_id}/r2/buckets/{bucket_name}.
///
/// 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 = r2_patch_bucket_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_patch_bucket_request<F>(
    client: DynNetClient,
    args: &R2PatchBucketArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PatchBucketResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}",
        args.account_id,
        args.bucket_name,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::patch(&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: R2PatchBucketResponse = 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}/r2/buckets/{bucket_name}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/r2/buckets/{bucket_name}.
///
/// 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 = r2_delete_bucket_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_delete_bucket_request<F>(
    client: DynNetClient,
    args: &R2DeleteBucketArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2V4Response>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}",
        args.account_id,
        args.bucket_name,
    );
    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: R2V4Response = 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}/r2/buckets/{bucket_name}/cors
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets/{bucket_name}/cors.
///
/// 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 = r2_get_bucket_cors_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_bucket_cors_policy_request<F>(
    client: DynNetClient,
    args: &R2GetBucketCorsPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetBucketCorsPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/cors",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetBucketCorsPolicyResponse = 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}/r2/buckets/{bucket_name}/cors
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/r2/buckets/{bucket_name}/cors.
///
/// 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 = r2_put_bucket_cors_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_put_bucket_cors_policy_request<F>(
    client: DynNetClient,
    args: &R2PutBucketCorsPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PutBucketCorsPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/cors",
        args.account_id,
        args.bucket_name,
    );
    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: R2PutBucketCorsPolicyResponse = 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}/r2/buckets/{bucket_name}/cors
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/r2/buckets/{bucket_name}/cors.
///
/// 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 = r2_delete_bucket_cors_policy_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_delete_bucket_cors_policy_request<F>(
    client: DynNetClient,
    args: &R2DeleteBucketCorsPolicyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2DeleteBucketCorsPolicyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/cors",
        args.account_id,
        args.bucket_name,
    );
    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: R2DeleteBucketCorsPolicyResponse = 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}/r2/buckets/{bucket_name}/lifecycle
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets/{bucket_name}/lifecycle.
///
/// 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 = r2_get_bucket_lifecycle_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_bucket_lifecycle_configuration_request<F>(
    client: DynNetClient,
    args: &R2GetBucketLifecycleConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetBucketLifecycleConfigurationResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/lifecycle",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetBucketLifecycleConfigurationResponse = 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}/r2/buckets/{bucket_name}/lifecycle
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/r2/buckets/{bucket_name}/lifecycle.
///
/// 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 = r2_put_bucket_lifecycle_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_put_bucket_lifecycle_configuration_request<F>(
    client: DynNetClient,
    args: &R2PutBucketLifecycleConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PutBucketLifecycleConfigurationResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/lifecycle",
        args.account_id,
        args.bucket_name,
    );
    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: R2PutBucketLifecycleConfigurationResponse = 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}/r2/buckets/{bucket_name}/local-uploads
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets/{bucket_name}/local-uploads.
///
/// 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 = r2_get_bucket_local_uploads_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_bucket_local_uploads_configuration_request<F>(
    client: DynNetClient,
    args: &R2GetBucketLocalUploadsConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetBucketLocalUploadsConfigurationResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/local-uploads",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetBucketLocalUploadsConfigurationResponse = 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}/r2/buckets/{bucket_name}/local-uploads
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/r2/buckets/{bucket_name}/local-uploads.
///
/// 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 = r2_put_bucket_local_uploads_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_put_bucket_local_uploads_configuration_request<F>(
    client: DynNetClient,
    args: &R2PutBucketLocalUploadsConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PutBucketLocalUploadsConfigurationResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/local-uploads",
        args.account_id,
        args.bucket_name,
    );
    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: R2PutBucketLocalUploadsConfigurationResponse = 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}/r2/buckets/{bucket_name}/lock
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets/{bucket_name}/lock.
///
/// 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 = r2_get_bucket_lock_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_bucket_lock_configuration_request<F>(
    client: DynNetClient,
    args: &R2GetBucketLockConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetBucketLockConfigurationResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/lock",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetBucketLockConfigurationResponse = 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}/r2/buckets/{bucket_name}/lock
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/r2/buckets/{bucket_name}/lock.
///
/// 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 = r2_put_bucket_lock_configuration_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_put_bucket_lock_configuration_request<F>(
    client: DynNetClient,
    args: &R2PutBucketLockConfigurationArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PutBucketLockConfigurationResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/lock",
        args.account_id,
        args.bucket_name,
    );
    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: R2PutBucketLockConfigurationResponse = 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}/r2/buckets/{bucket_name}/sippy
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/buckets/{bucket_name}/sippy.
///
/// 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 = r2_get_bucket_sippy_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_bucket_sippy_config_request<F>(
    client: DynNetClient,
    args: &R2GetBucketSippyConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetBucketSippyConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/sippy",
        args.account_id,
        args.bucket_name,
    );
    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: R2GetBucketSippyConfigResponse = 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}/r2/buckets/{bucket_name}/sippy
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/r2/buckets/{bucket_name}/sippy.
///
/// 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 = r2_put_bucket_sippy_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_put_bucket_sippy_config_request<F>(
    client: DynNetClient,
    args: &R2PutBucketSippyConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2PutBucketSippyConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/sippy",
        args.account_id,
        args.bucket_name,
    );
    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: R2PutBucketSippyConfigResponse = 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}/r2/buckets/{bucket_name}/sippy
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/r2/buckets/{bucket_name}/sippy.
///
/// 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 = r2_delete_bucket_sippy_config_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_delete_bucket_sippy_config_request<F>(
    client: DynNetClient,
    args: &R2DeleteBucketSippyConfigArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2DeleteBucketSippyConfigResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/buckets/{}/sippy",
        args.account_id,
        args.bucket_name,
    );
    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: R2DeleteBucketSippyConfigResponse = 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}/r2/metrics
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/r2/metrics.
///
/// 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 = r2_get_account_level_metrics_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_get_account_level_metrics_request<F>(
    client: DynNetClient,
    args: &R2GetAccountLevelMetricsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2GetAccountLevelMetricsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/metrics",
        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: R2GetAccountLevelMetricsResponse = 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}/r2/temp-access-credentials
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/r2/temp-access-credentials.
///
/// 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 = r2_create_temp_access_credentials_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn r2_create_temp_access_credentials_request<F>(
    client: DynNetClient,
    args: &R2CreateTempAccessCredentialsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<R2CreateTempAccessCredentialsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/r2/temp-access-credentials",
        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: R2CreateTempAccessCredentialsResponse = 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}/storage/kv/namespaces
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/storage/kv/namespaces.
///
/// 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 = workers_kv_namespace_list_namespaces_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_list_namespaces_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceListNamespacesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceListNamespacesResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces",
        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("page", args.page.as_deref());
    builder = builder.query("per_page", args.per_page.as_deref());
    builder = builder.query("order", args.order.as_deref());
    builder = builder.query("direction", args.direction.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: WorkersKvNamespaceListNamespacesResponse = 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}/storage/kv/namespaces
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/storage/kv/namespaces.
///
/// 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 = workers_kv_namespace_create_a_namespace_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_create_a_namespace_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceCreateANamespaceArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceCreateANamespaceResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces",
        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: WorkersKvNamespaceCreateANamespaceResponse = 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}/storage/kv/namespaces/{namespace_id}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/storage/kv/namespaces/{namespace_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 = workers_kv_namespace_get_a_namespace_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_get_a_namespace_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceGetANamespaceArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceGetANamespaceResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}",
        args.account_id,
        args.namespace_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: WorkersKvNamespaceGetANamespaceResponse = 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}/storage/kv/namespaces/{namespace_id}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/storage/kv/namespaces/{namespace_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 = workers_kv_namespace_rename_a_namespace_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_rename_a_namespace_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceRenameANamespaceArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceRenameANamespaceResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}",
        args.account_id,
        args.namespace_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: WorkersKvNamespaceRenameANamespaceResponse = 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}/storage/kv/namespaces/{namespace_id}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/storage/kv/namespaces/{namespace_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 = workers_kv_namespace_remove_a_namespace_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_remove_a_namespace_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceRemoveANamespaceArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvApiResponseCommonNoResult>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}",
        args.account_id,
        args.namespace_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: WorkersKvApiResponseCommonNoResult = 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}/storage/kv/namespaces/{namespace_id}/bulk
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk.
///
/// 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 = workers_kv_namespace_write_multiple_key_value_pairs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_write_multiple_key_value_pairs_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceWriteMultipleKeyValuePairsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceWriteMultipleKeyValuePairsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/bulk",
        args.account_id,
        args.namespace_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: WorkersKvNamespaceWriteMultipleKeyValuePairsResponse = 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}/storage/kv/namespaces/{namespace_id}/bulk/delete
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk/delete.
///
/// 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 = workers_kv_namespace_delete_multiple_key_value_pairs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_delete_multiple_key_value_pairs_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceDeleteMultipleKeyValuePairsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceDeleteMultipleKeyValuePairsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/bulk/delete",
        args.account_id,
        args.namespace_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: WorkersKvNamespaceDeleteMultipleKeyValuePairsResponse = 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}/storage/kv/namespaces/{namespace_id}/bulk/get
// -----------------------------------------------------------------------------

/// POST /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk/get.
///
/// 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 = workers_kv_namespace_get_multiple_key_value_pairs_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_get_multiple_key_value_pairs_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceGetMultipleKeyValuePairsArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceGetMultipleKeyValuePairsResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/bulk/get",
        args.account_id,
        args.namespace_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: WorkersKvNamespaceGetMultipleKeyValuePairsResponse = 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}/storage/kv/namespaces/{namespace_id}/keys
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/keys.
///
/// 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 = workers_kv_namespace_list_a_namespace_s_keys_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_list_a_namespace_s_keys_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceListANamespaceSKeysArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceListANamespaceSKeysResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/keys",
        args.account_id,
        args.namespace_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("limit", args.limit.as_deref());
    builder = builder.query("prefix", args.prefix.as_deref());
    builder = builder.query("cursor", args.cursor.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: WorkersKvNamespaceListANamespaceSKeysResponse = 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}/storage/kv/namespaces/{namespace_id}/metadata/{key_name}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/metadata/{key_name}.
///
/// 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 = workers_kv_namespace_read_the_metadata_for_a_key_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_read_the_metadata_for_a_key_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceReadTheMetadataForAKeyArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvNamespaceReadTheMetadataForAKeyResponse>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/metadata/{}",
        args.account_id,
        args.namespace_id,
        args.key_name,
    );
    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: WorkersKvNamespaceReadTheMetadataForAKeyResponse = 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}/storage/kv/namespaces/{namespace_id}/values/{key_name}
// -----------------------------------------------------------------------------

/// GET /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/values/{key_name}.
///
/// 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 = workers_kv_namespace_read_key_value_pair_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_read_key_value_pair_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceReadKeyValuePairArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<()>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/values/{}",
        args.account_id,
        args.namespace_id,
        args.key_name,
    );
    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 });
    }
    Ok(ApiResponse { status: status as u16, headers, body: () })
}

// -----------------------------------------------------------------------------
// PUT /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/values/{key_name}
// -----------------------------------------------------------------------------

/// PUT /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/values/{key_name}.
///
/// 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 = workers_kv_namespace_write_key_value_pair_with_metadata_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_write_key_value_pair_with_metadata_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceWriteKeyValuePairWithMetadataArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvApiResponseCommonNoResult>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/values/{}",
        args.account_id,
        args.namespace_id,
        args.key_name,
    );
    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.query("expiration", args.expiration.as_deref());
    builder = builder.query("expiration_ttl", args.expiration_ttl.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: WorkersKvApiResponseCommonNoResult = 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}/storage/kv/namespaces/{namespace_id}/values/{key_name}
// -----------------------------------------------------------------------------

/// DELETE /accounts/{account_id}/storage/kv/namespaces/{namespace_id}/values/{key_name}.
///
/// 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 = workers_kv_namespace_delete_key_value_pair_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn workers_kv_namespace_delete_key_value_pair_request<F>(
    client: DynNetClient,
    args: &WorkersKvNamespaceDeleteKeyValuePairArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<WorkersKvApiResponseCommonNoResult>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/storage/kv/namespaces/{}/values/{}",
        args.account_id,
        args.namespace_id,
        args.key_name,
    );
    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: WorkersKvApiResponseCommonNoResult = 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 })
}