foundation_deployment_cloudflare 0.1.2

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

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

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

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

/// `StreamAdditionalAudio` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamAdditionalAudio {
    /// default property.
    pub default: Option<StreamAudioDefault>,
    /// label property.
    pub label: Option<StreamAudioLabel>,
    /// status property.
    pub status: Option<StreamAudioState>,
    /// uid property.
    pub uid: Option<StreamIdentifier>,
}

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

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

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

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

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

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

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

/// `StreamCaptions` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamCaptions {
    /// generated property.
    pub generated: Option<StreamGeneratedCaption>,
    /// label property.
    pub label: Option<StreamLabel>,
    /// language property.
    pub language: Option<StreamLanguage>,
    /// status property.
    pub status: Option<StreamCaptionStatus>,
}

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

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

/// `StreamClipping` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamClipping {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// clippedFromVideoUID property.
    #[serde(rename = "clippedFromVideoUID")]
    pub clipped_from_video_uid: Option<StreamClippedFromVideoUid>,
    /// created property.
    pub created: Option<StreamClippingCreated>,
    /// creator property.
    pub creator: Option<StreamCreator>,
    /// endTimeSeconds property.
    #[serde(rename = "endTimeSeconds")]
    pub end_time_seconds: Option<StreamEndTimeSeconds>,
    /// maxDurationSeconds property.
    #[serde(rename = "maxDurationSeconds")]
    pub max_duration_seconds: Option<StreamMaxDurationSeconds>,
    /// meta property.
    pub meta: Option<StreamMediaMetadata>,
    /// modified property.
    pub modified: Option<StreamLiveInputModified>,
    /// playback property.
    pub playback: Option<StreamPlayback>,
    /// preview property.
    pub preview: Option<StreamPreview>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamRequireSignedURLs>,
    /// startTimeSeconds property.
    #[serde(rename = "startTimeSeconds")]
    pub start_time_seconds: Option<StreamStartTimeSeconds>,
    /// status property.
    pub status: Option<StreamMediaState>,
    /// thumbnailTimestampPct property.
    #[serde(rename = "thumbnailTimestampPct")]
    pub thumbnail_timestamp_pct: Option<StreamThumbnailTimestampPct>,
    /// watermark property.
    pub watermark: Option<StreamWatermarkAtUpload>,
}

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

/// `StreamCopyAudioTrack` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamCopyAudioTrack {
    /// label property.
    pub label: StreamAudioLabel,
    /// url property.
    pub url: Option<String>,
}

/// `StreamCreateInputRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamCreateInputRequest {
    /// defaultCreator property.
    #[serde(rename = "defaultCreator")]
    pub default_creator: Option<StreamLiveInputDefaultCreator>,
    /// deleteRecordingAfterDays property.
    #[serde(rename = "deleteRecordingAfterDays")]
    pub delete_recording_after_days: Option<StreamLiveInputRecordingDeletion>,
    /// enabled property.
    pub enabled: Option<StreamLiveInputEnabled>,
    /// meta property.
    pub meta: Option<StreamLiveInputMetadata>,
    /// recording property.
    pub recording: Option<StreamLiveInputRecordingSettings>,
}

/// `StreamCreateOutputRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamCreateOutputRequest {
    /// enabled property.
    pub enabled: Option<StreamOutputEnabled>,
    /// streamKey property.
    #[serde(rename = "streamKey")]
    pub stream_key: StreamOutputStreamKey,
    /// url property.
    pub url: StreamOutputUrl,
}

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

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

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

/// `StreamDirectUploadRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamDirectUploadRequest {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// creator property.
    pub creator: Option<StreamCreator>,
    /// expiry property.
    pub expiry: Option<String>,
    /// maxDurationSeconds property.
    #[serde(rename = "maxDurationSeconds")]
    pub max_duration_seconds: StreamMaxDurationSeconds,
    /// meta property.
    pub meta: Option<StreamMediaMetadata>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamRequireSignedURLs>,
    /// scheduledDeletion property.
    #[serde(rename = "scheduledDeletion")]
    pub scheduled_deletion: Option<StreamScheduledDeletion>,
    /// thumbnailTimestampPct property.
    #[serde(rename = "thumbnailTimestampPct")]
    pub thumbnail_timestamp_pct: Option<StreamThumbnailTimestampPct>,
    /// watermark property.
    pub watermark: Option<StreamWatermarkAtUpload>,
}

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

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

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

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

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

/// `StreamDownloads` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamDownloads {
    /// percentComplete property.
    #[serde(rename = "percentComplete")]
    pub percent_complete: Option<StreamDownloadPercentComplete>,
    /// status property.
    pub status: Option<StreamDownloadStatus>,
    /// url property.
    pub url: Option<StreamDownloadUrl>,
}

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

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

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

/// `StreamEditAudioTrack` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamEditAudioTrack {
    /// default property.
    pub default: Option<StreamAudioDefault>,
    /// label property.
    pub label: Option<StreamAudioLabel>,
}

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

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

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

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

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

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

/// `StreamInput` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamInput {
    /// height property.
    pub height: Option<i64>,
    /// width property.
    pub width: Option<i64>,
}

/// `StreamInputRtmps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamInputRtmps {
    /// streamKey property.
    #[serde(rename = "streamKey")]
    pub stream_key: Option<StreamInputRtmpsStreamKey>,
    /// url property.
    pub url: Option<StreamInputRtmpsUrl>,
}

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

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

/// `StreamInputSrt` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamInputSrt {
    /// passphrase property.
    pub passphrase: Option<StreamInputSrtStreamPassphrase>,
    /// streamId property.
    #[serde(rename = "streamId")]
    pub stream_id: Option<StreamInputSrtStreamId>,
    /// url property.
    pub url: Option<StreamInputSrtUrl>,
}

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

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

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

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

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

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

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

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

/// `StreamKeys` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamKeys {
    /// created property.
    pub created: Option<StreamSigningKeyCreated>,
    /// id property.
    pub id: Option<StreamSchemasIdentifier>,
    /// jwk property.
    pub jwk: Option<StreamJwk>,
    /// pem property.
    pub pem: Option<StreamPem>,
}

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

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

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

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

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

/// `StreamLiveInput` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamLiveInput {
    /// created property.
    pub created: Option<StreamLiveInputCreated>,
    /// deleteRecordingAfterDays property.
    #[serde(rename = "deleteRecordingAfterDays")]
    pub delete_recording_after_days: Option<StreamLiveInputRecordingDeletion>,
    /// enabled property.
    pub enabled: Option<StreamLiveInputEnabled>,
    /// meta property.
    pub meta: Option<StreamLiveInputMetadata>,
    /// modified property.
    pub modified: Option<StreamLiveInputModified>,
    /// recording property.
    pub recording: Option<StreamLiveInputRecordingSettings>,
    /// rtmps property.
    pub rtmps: Option<StreamInputRtmps>,
    /// rtmpsPlayback property.
    #[serde(rename = "rtmpsPlayback")]
    pub rtmps_playback: Option<StreamPlaybackRtmps>,
    /// srt property.
    pub srt: Option<StreamInputSrt>,
    /// srtPlayback property.
    #[serde(rename = "srtPlayback")]
    pub srt_playback: Option<StreamPlaybackSrt>,
    /// status property.
    pub status: Option<StreamLiveInputStatus>,
    /// uid property.
    pub uid: Option<StreamLiveInputIdentifier>,
    /// webRTC property.
    #[serde(rename = "webRTC")]
    pub web_rtc: Option<StreamInputWebrtc>,
    /// webRTCPlayback property.
    #[serde(rename = "webRTCPlayback")]
    pub web_rtc_playback: Option<StreamPlaybackWebrtc>,
}

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

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

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

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

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

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

/// `StreamLiveInputObjectWithoutUrl` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamLiveInputObjectWithoutUrl {
    /// created property.
    pub created: Option<StreamLiveInputCreated>,
    /// deleteRecordingAfterDays property.
    #[serde(rename = "deleteRecordingAfterDays")]
    pub delete_recording_after_days: Option<StreamLiveInputRecordingDeletion>,
    /// enabled property.
    pub enabled: Option<StreamLiveInputEnabled>,
    /// meta property.
    pub meta: Option<StreamLiveInputMetadata>,
    /// modified property.
    pub modified: Option<StreamLiveInputModified>,
    /// uid property.
    pub uid: Option<StreamLiveInputIdentifier>,
}

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

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

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

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

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

/// `StreamLiveInputRecordingSettings` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamLiveInputRecordingSettings {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// hideLiveViewerCount property.
    #[serde(rename = "hideLiveViewerCount")]
    pub hide_live_viewer_count: Option<StreamLiveInputRecordingHideLiveViewerCount>,
    /// mode property.
    pub mode: Option<StreamLiveInputRecordingMode>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamLiveInputRecordingRequireSignedURLs>,
    /// timeoutSeconds property.
    #[serde(rename = "timeoutSeconds")]
    pub timeout_seconds: Option<StreamLiveInputRecordingTimeoutSeconds>,
}

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

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

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

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

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

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

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

/// `StreamMediaStatus` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamMediaStatus {
    /// errorReasonCode property.
    #[serde(rename = "errorReasonCode")]
    pub error_reason_code: Option<StreamErrorReasonCode>,
    /// errorReasonText property.
    #[serde(rename = "errorReasonText")]
    pub error_reason_text: Option<StreamErrorReasonText>,
    /// pctComplete property.
    #[serde(rename = "pctComplete")]
    pub pct_complete: Option<StreamPctComplete>,
    /// state property.
    pub state: Option<StreamMediaState>,
}

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

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

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

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

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

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

/// `StreamOutput` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamOutput {
    /// enabled property.
    pub enabled: Option<StreamOutputEnabled>,
    /// streamKey property.
    #[serde(rename = "streamKey")]
    pub stream_key: Option<StreamOutputStreamKey>,
    /// uid property.
    pub uid: Option<StreamOutputIdentifier>,
    /// url property.
    pub url: Option<StreamOutputUrl>,
}

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

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

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

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

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

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

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

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

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

/// `StreamPlayback` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamPlayback {
    /// dash property.
    pub dash: Option<String>,
    /// hls property.
    pub hls: Option<String>,
}

/// `StreamPlaybackRtmps` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamPlaybackRtmps {
    /// streamKey property.
    #[serde(rename = "streamKey")]
    pub stream_key: Option<StreamPlaybackRtmpsStreamKey>,
    /// url property.
    pub url: Option<StreamPlaybackRtmpsUrl>,
}

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

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

/// `StreamPlaybackSrt` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamPlaybackSrt {
    /// passphrase property.
    pub passphrase: Option<StreamPlaybackSrtStreamPassphrase>,
    /// streamId property.
    #[serde(rename = "streamId")]
    pub stream_id: Option<StreamPlaybackSrtStreamId>,
    /// url property.
    pub url: Option<StreamPlaybackSrtUrl>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `StreamSignedTokenRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamSignedTokenRequest {
    /// accessRules property.
    #[serde(rename = "accessRules")]
    pub access_rules: Option<Vec<StreamAccessRules>>,
    /// downloadable property.
    pub downloadable: Option<bool>,
    /// exp property.
    pub exp: Option<i64>,
    /// id property.
    pub id: Option<String>,
    /// nbf property.
    pub nbf: Option<i64>,
    /// pem property.
    pub pem: Option<String>,
}

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

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

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

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

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

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

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

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

/// `StreamUpdateInputRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamUpdateInputRequest {
    /// defaultCreator property.
    #[serde(rename = "defaultCreator")]
    pub default_creator: Option<StreamLiveInputDefaultCreator>,
    /// deleteRecordingAfterDays property.
    #[serde(rename = "deleteRecordingAfterDays")]
    pub delete_recording_after_days: Option<StreamLiveInputRecordingDeletion>,
    /// enabled property.
    pub enabled: Option<StreamLiveInputEnabled>,
    /// meta property.
    pub meta: Option<StreamLiveInputMetadata>,
    /// recording property.
    pub recording: Option<StreamLiveInputRecordingSettings>,
}

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

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

/// `StreamVideoClipStandard` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamVideoClipStandard {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// clippedFromVideoUID property.
    #[serde(rename = "clippedFromVideoUID")]
    pub clipped_from_video_uid: StreamClippedFromVideoUid,
    /// creator property.
    pub creator: Option<StreamCreator>,
    /// endTimeSeconds property.
    #[serde(rename = "endTimeSeconds")]
    pub end_time_seconds: StreamEndTimeSeconds,
    /// maxDurationSeconds property.
    #[serde(rename = "maxDurationSeconds")]
    pub max_duration_seconds: Option<StreamMaxDurationSeconds>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamRequireSignedURLs>,
    /// startTimeSeconds property.
    #[serde(rename = "startTimeSeconds")]
    pub start_time_seconds: StreamStartTimeSeconds,
    /// thumbnailTimestampPct property.
    #[serde(rename = "thumbnailTimestampPct")]
    pub thumbnail_timestamp_pct: Option<StreamThumbnailTimestampPct>,
    /// watermark property.
    pub watermark: Option<StreamWatermarkAtUpload>,
}

/// `StreamVideoCopyRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamVideoCopyRequest {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// creator property.
    pub creator: Option<StreamCreator>,
    /// meta property.
    pub meta: Option<StreamMediaMetadata>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamRequireSignedURLs>,
    /// scheduledDeletion property.
    #[serde(rename = "scheduledDeletion")]
    pub scheduled_deletion: Option<StreamScheduledDeletion>,
    /// thumbnailTimestampPct property.
    #[serde(rename = "thumbnailTimestampPct")]
    pub thumbnail_timestamp_pct: Option<StreamThumbnailTimestampPct>,
    /// url property.
    pub url: String,
    /// watermark property.
    pub watermark: Option<StreamWatermarkAtUpload>,
}

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

/// `StreamVideoUpdate` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamVideoUpdate {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// creator property.
    pub creator: Option<StreamCreator>,
    /// maxDurationSeconds property.
    #[serde(rename = "maxDurationSeconds")]
    pub max_duration_seconds: Option<StreamMaxDurationSeconds>,
    /// meta property.
    pub meta: Option<StreamMediaMetadata>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamRequireSignedURLs>,
    /// scheduledDeletion property.
    #[serde(rename = "scheduledDeletion")]
    pub scheduled_deletion: Option<StreamScheduledDeletion>,
    /// thumbnailTimestampPct property.
    #[serde(rename = "thumbnailTimestampPct")]
    pub thumbnail_timestamp_pct: Option<StreamThumbnailTimestampPct>,
    /// uploadExpiry property.
    #[serde(rename = "uploadExpiry")]
    pub upload_expiry: Option<StreamOneTimeUploadExpiry>,
}

/// `StreamVideos` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamVideos {
    /// allowedOrigins property.
    #[serde(rename = "allowedOrigins")]
    pub allowed_origins: Option<Vec<String>>,
    /// created property.
    pub created: Option<StreamCreated>,
    /// creator property.
    pub creator: Option<StreamCreator>,
    /// duration property.
    pub duration: Option<StreamDuration>,
    /// input property.
    pub input: Option<StreamInput>,
    /// liveInput property.
    #[serde(rename = "liveInput")]
    pub live_input: Option<StreamLiveInput>,
    /// maxDurationSeconds property.
    #[serde(rename = "maxDurationSeconds")]
    pub max_duration_seconds: Option<StreamMaxDurationSeconds>,
    /// meta property.
    pub meta: Option<StreamMediaMetadata>,
    /// modified property.
    pub modified: Option<StreamModified>,
    /// playback property.
    pub playback: Option<StreamPlayback>,
    /// preview property.
    pub preview: Option<StreamPreview>,
    /// readyToStream property.
    #[serde(rename = "readyToStream")]
    pub ready_to_stream: Option<StreamReadyToStream>,
    /// readyToStreamAt property.
    #[serde(rename = "readyToStreamAt")]
    pub ready_to_stream_at: Option<StreamReadyToStreamAt>,
    /// requireSignedURLs property.
    #[serde(rename = "requireSignedURLs")]
    pub require_signed_ur_ls: Option<StreamRequireSignedURLs>,
    /// scheduledDeletion property.
    #[serde(rename = "scheduledDeletion")]
    pub scheduled_deletion: Option<StreamScheduledDeletion>,
    /// size property.
    pub size: Option<StreamSize>,
    /// status property.
    pub status: Option<StreamMediaStatus>,
    /// thumbnail property.
    pub thumbnail: Option<StreamThumbnailUrl>,
    /// thumbnailTimestampPct property.
    #[serde(rename = "thumbnailTimestampPct")]
    pub thumbnail_timestamp_pct: Option<StreamThumbnailTimestampPct>,
    /// uid property.
    pub uid: Option<StreamIdentifier>,
    /// uploadExpiry property.
    #[serde(rename = "uploadExpiry")]
    pub upload_expiry: Option<StreamOneTimeUploadExpiry>,
    /// uploaded property.
    pub uploaded: Option<StreamUploaded>,
    /// watermark property.
    pub watermark: Option<StreamWatermarks>,
}

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

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

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

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

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

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

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

/// `StreamWatermarks` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamWatermarks {
    /// created property.
    pub created: Option<StreamWatermarkCreated>,
    /// downloadedFrom property.
    #[serde(rename = "downloadedFrom")]
    pub downloaded_from: Option<StreamDownloadedFrom>,
    /// height property.
    pub height: Option<StreamHeight>,
    /// name property.
    pub name: Option<StreamName>,
    /// opacity property.
    pub opacity: Option<StreamOpacity>,
    /// padding property.
    pub padding: Option<StreamPadding>,
    /// position property.
    pub position: Option<StreamPosition>,
    /// scale property.
    pub scale: Option<StreamScale>,
    /// size property.
    pub size: Option<StreamWatermarkSize>,
    /// uid property.
    pub uid: Option<StreamWatermarkIdentifier>,
    /// width property.
    pub width: Option<StreamWidth>,
}

/// `StreamWebhookRequest` type.
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct StreamWebhookRequest {
    /// notificationUrl property.
    #[serde(rename = "notificationUrl")]
    pub notification_url: StreamNotificationUrl,
}

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

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

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

/// Arguments for [`stream-video-clipping-clip-videos-given-a-start-and-end-time_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideoClippingClipVideosGivenAStartAndEndTimeArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamVideoClipStandard,
}

/// Arguments for [`stream-videos-upload-videos-from-a-url_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosUploadVideosFromAUrlArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamVideoCopyRequest,
}

/// Arguments for [`stream-videos-upload-videos-via-direct-upload-ur-ls_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosUploadVideosViaDirectUploadUrLsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamDirectUploadRequest,
}

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

/// Arguments for [`stream-signing-keys-create-signing-keys_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSigningKeysCreateSigningKeysArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-signing-keys-delete-signing-keys_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSigningKeysDeleteSigningKeysArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-live-inputs-list-live-inputs_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsListLiveInputsArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `include_counts`.
    pub include_counts: Option<String>,
}

/// Arguments for [`stream-live-inputs-create-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsCreateALiveInputArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamCreateInputRequest,
}

/// Arguments for [`stream-live-inputs-retrieve-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsRetrieveALiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-live-inputs-update-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsUpdateALiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamUpdateInputRequest,
}

/// Arguments for [`stream-live-inputs-delete-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsDeleteALiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-live-inputs-disable-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsDisableALiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-live-inputs-enable-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsEnableALiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-live-inputs-list-all-outputs-associated-with-a-specified-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsListAllOutputsAssociatedWithASpecifiedLiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-live-inputs-create-a-new-output,-connected-to-a-live-input_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsCreateANewOutputConnectedToALiveInputArgs {
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamCreateOutputRequest,
}

/// Arguments for [`stream-live-inputs-update-an-output_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsUpdateAnOutputArgs {
    /// Path parameter: `output_identifier`.
    pub output_identifier: String,
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamUpdateOutputRequest,
}

/// Arguments for [`stream-live-inputs-delete-an-output_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamLiveInputsDeleteAnOutputArgs {
    /// Path parameter: `output_identifier`.
    pub output_identifier: String,
    /// Path parameter: `live_input_identifier`.
    pub live_input_identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-videos-storage-usage_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosStorageUsageArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Query parameter: `creator`.
    pub creator: Option<String>,
}

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

/// Arguments for [`stream-watermark-profile-create-watermark-profiles-via-basic-upload_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamWatermarkProfileCreateWatermarkProfilesViaBasicUploadArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-watermark-profile-watermark-profile-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamWatermarkProfileWatermarkProfileDetailsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-watermark-profile-delete-watermark-profiles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamWatermarkProfileDeleteWatermarkProfilesArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-webhook-view-webhooks_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamWebhookViewWebhooksArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-webhook-create-webhooks_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamWebhookCreateWebhooksArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamWebhookRequest,
}

/// Arguments for [`stream-webhook-delete-webhooks_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamWebhookDeleteWebhooksArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-videos-retrieve-video-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosRetrieveVideoDetailsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-videos-update-video-details_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosUpdateVideoDetailsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamVideoUpdate,
}

/// Arguments for [`stream-videos-delete-video_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosDeleteVideoArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

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

/// Arguments for [`add-audio-track_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct AddAudioTrackArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Request body.
    pub body: StreamCopyAudioTrack,
}

/// Arguments for [`edit-audio-tracks_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct EditAudioTracksArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `audio_identifier`.
    pub audio_identifier: String,
    /// Request body.
    pub body: StreamEditAudioTrack,
}

/// Arguments for [`delete-audio-tracks_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteAudioTracksArgs {
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `audio_identifier`.
    pub audio_identifier: String,
}

/// Arguments for [`stream-subtitles/-captions-list-captions-or-subtitles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSubtitlesCaptionsListCaptionsOrSubtitlesArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-subtitles/-captions-get-caption-or-subtitle-for-language_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSubtitlesCaptionsGetCaptionOrSubtitleForLanguageArgs {
    /// Path parameter: `language`.
    pub language: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-subtitles/-captions-upload-captions-or-subtitles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSubtitlesCaptionsUploadCaptionsOrSubtitlesArgs {
    /// Path parameter: `language`.
    pub language: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-subtitles/-captions-delete-captions-or-subtitles_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSubtitlesCaptionsDeleteCaptionsOrSubtitlesArgs {
    /// Path parameter: `language`.
    pub language: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-subtitles/-captions-generate-caption-or-subtitle-for-language_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSubtitlesCaptionsGenerateCaptionOrSubtitleForLanguageArgs {
    /// Path parameter: `language`.
    pub language: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-subtitles/-captions-get-vtt-caption-or-subtitle_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamSubtitlesCaptionsGetVttCaptionOrSubtitleArgs {
    /// Path parameter: `language`.
    pub language: String,
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-m-p-4-downloads-list-downloads_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamMP4DownloadsListDownloadsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-m-p-4-downloads-create-downloads_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamMP4DownloadsCreateDownloadsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-m-p-4-downloads-delete-downloads_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamMP4DownloadsDeleteDownloadsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-downloads-create-type-specific-downloads_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamDownloadsCreateTypeSpecificDownloadsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `download_type`.
    pub download_type: String,
}

/// Arguments for [`stream-downloads-delete-type-specific-downloads_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamDownloadsDeleteTypeSpecificDownloadsArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Path parameter: `download_type`.
    pub download_type: String,
}

/// Arguments for [`stream-videos-retreieve-embed-code-html_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosRetreieveEmbedCodeHtmlArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
}

/// Arguments for [`stream-videos-create-signed-url-tokens-for-videos_request`].
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct StreamVideosCreateSignedUrlTokensForVideosArgs {
    /// Path parameter: `identifier`.
    pub identifier: String,
    /// Path parameter: `account_id`.
    pub account_id: String,
    /// Request body.
    pub body: StreamSignedTokenRequest,
}

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/stream/clip
// -----------------------------------------------------------------------------

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

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

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

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

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

    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: StreamKeyGenerationResponse = 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}/stream/keys/{identifier}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// POST /accounts/{account_id}/stream/live_inputs/{live_input_identifier}/disable
// -----------------------------------------------------------------------------

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

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

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

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

/// PUT /accounts/{account_id}/stream/live_inputs/{live_input_identifier}/outputs/{output_identifier}.
///
/// 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 = stream_live_inputs_update_an_output_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn stream_live_inputs_update_an_output_request<F>(
    client: DynNetClient,
    args: &StreamLiveInputsUpdateAnOutputArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<StreamOutputResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/stream/live_inputs/{}/outputs/{}",
        args.account_id,
        args.live_input_identifier,
        args.output_identifier,
    );
    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: StreamOutputResponseSingle = 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}/stream/live_inputs/{live_input_identifier}/outputs/{output_identifier}
// -----------------------------------------------------------------------------

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

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

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

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

    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: StreamWatermarkResponseSingle = 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}/stream/watermarks/{identifier}
// -----------------------------------------------------------------------------

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

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

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

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

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

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: StreamWebhookResponseSingle = 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}/stream/webhook
// -----------------------------------------------------------------------------

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

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

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: StreamDeletedResponse = 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}/stream/{identifier}
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

    builder = builder.body_json(&args.body)
        .map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;

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

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

    let status: usize = response.get_status().into();
    let headers = response.get_headers_ref().clone();
    if status < 200 || status >= 300 {
        let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
        let body = (!error_bytes.is_empty())
            .then(|| String::from_utf8_lossy(&error_bytes).into_owned());
        return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
    }
    let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
    let parsed: StreamAddAudioTrackResponse = 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}/stream/{identifier}/audio/{audio_identifier}
// -----------------------------------------------------------------------------

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

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

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

/// PUT /accounts/{account_id}/stream/{identifier}/captions/{language}.
///
/// 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 = stream_subtitles_captions_upload_captions_or_subtitles_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn stream_subtitles_captions_upload_captions_or_subtitles_request<F>(
    client: DynNetClient,
    args: &StreamSubtitlesCaptionsUploadCaptionsOrSubtitlesArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<StreamLanguageResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/stream/{}/captions/{}",
        args.account_id,
        args.identifier,
        args.language,
    );
    let endpoint_url = format!("{}{}", base_url, path);

    let mut builder = PreparedRequestBuilder::put(&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: StreamLanguageResponseSingle = 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}/stream/{identifier}/captions/{language}
// -----------------------------------------------------------------------------

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

/// POST /accounts/{account_id}/stream/{identifier}/captions/{language}/generate.
///
/// 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 = stream_subtitles_captions_generate_caption_or_subtitle_for_language_request(client.clone(), &args, Some(|b: &mut PreparedRequestBuilder| {
///     b.header("X-Custom-Header", "value");
/// })).await?;
/// ```
pub async fn stream_subtitles_captions_generate_caption_or_subtitle_for_language_request<F>(
    client: DynNetClient,
    args: &StreamSubtitlesCaptionsGenerateCaptionOrSubtitleForLanguageArgs,
    base_url: &str,
    builder_mod: Option<F>,
) -> Result<ApiResponse<StreamLanguageResponseSingle>, super::shared::ApiError>
where
    F: FnOnce(&mut PreparedRequestBuilder),
{
    let path = format!("/accounts/{}/stream/{}/captions/{}/generate",
        args.account_id,
        args.identifier,
        args.language,
    );
    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: StreamLanguageResponseSingle = 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}/stream/{identifier}/captions/{language}/vtt
// -----------------------------------------------------------------------------

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

// -----------------------------------------------------------------------------
// GET /accounts/{account_id}/stream/{identifier}/downloads
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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