use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AacSettings {
#[serde(rename = "AudioDescriptionBroadcasterMix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_description_broadcaster_mix: Option<String>,
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "CodecProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_profile: Option<String>,
#[serde(rename = "CodingMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub coding_mode: Option<String>,
#[serde(rename = "RateControlMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rate_control_mode: Option<String>,
#[serde(rename = "RawFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raw_format: Option<String>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<i64>,
#[serde(rename = "Specification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub specification: Option<String>,
#[serde(rename = "VbrQuality")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vbr_quality: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Ac3Settings {
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "BitstreamMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitstream_mode: Option<String>,
#[serde(rename = "CodingMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub coding_mode: Option<String>,
#[serde(rename = "Dialnorm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dialnorm: Option<i64>,
#[serde(rename = "DynamicRangeCompressionProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_range_compression_profile: Option<String>,
#[serde(rename = "LfeFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lfe_filter: Option<String>,
#[serde(rename = "MetadataControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata_control: Option<String>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AccelerationSettings {
#[serde(rename = "Mode")]
pub mode: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AiffSettings {
#[serde(rename = "BitDepth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bit_depth: Option<i64>,
#[serde(rename = "Channels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channels: Option<i64>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AncillarySourceSettings {
#[serde(rename = "SourceAncillaryChannelNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_ancillary_channel_number: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateCertificateRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateCertificateResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AudioCodecSettings {
#[serde(rename = "AacSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aac_settings: Option<AacSettings>,
#[serde(rename = "Ac3Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ac_3_settings: Option<Ac3Settings>,
#[serde(rename = "AiffSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aiff_settings: Option<AiffSettings>,
#[serde(rename = "Codec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec: Option<String>,
#[serde(rename = "Eac3Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eac_3_settings: Option<Eac3Settings>,
#[serde(rename = "Mp2Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mp_2_settings: Option<Mp2Settings>,
#[serde(rename = "WavSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub wav_settings: Option<WavSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AudioDescription {
#[serde(rename = "AudioNormalizationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_normalization_settings: Option<AudioNormalizationSettings>,
#[serde(rename = "AudioSourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_source_name: Option<String>,
#[serde(rename = "AudioType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_type: Option<i64>,
#[serde(rename = "AudioTypeControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_type_control: Option<String>,
#[serde(rename = "CodecSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_settings: Option<AudioCodecSettings>,
#[serde(rename = "CustomLanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_language_code: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageCodeControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code_control: Option<String>,
#[serde(rename = "RemixSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remix_settings: Option<RemixSettings>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AudioNormalizationSettings {
#[serde(rename = "Algorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm: Option<String>,
#[serde(rename = "AlgorithmControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_control: Option<String>,
#[serde(rename = "CorrectionGateLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub correction_gate_level: Option<i64>,
#[serde(rename = "LoudnessLogging")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loudness_logging: Option<String>,
#[serde(rename = "PeakCalculation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub peak_calculation: Option<String>,
#[serde(rename = "TargetLkfs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_lkfs: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AudioSelector {
#[serde(rename = "CustomLanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_language_code: Option<String>,
#[serde(rename = "DefaultSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_selection: Option<String>,
#[serde(rename = "ExternalAudioFileInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_audio_file_input: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "Offset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offset: Option<i64>,
#[serde(rename = "Pids")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pids: Option<Vec<i64>>,
#[serde(rename = "ProgramSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_selection: Option<i64>,
#[serde(rename = "RemixSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remix_settings: Option<RemixSettings>,
#[serde(rename = "SelectorType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selector_type: Option<String>,
#[serde(rename = "Tracks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracks: Option<Vec<i64>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AudioSelectorGroup {
#[serde(rename = "AudioSelectorNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_selector_names: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AvailBlanking {
#[serde(rename = "AvailBlankingImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub avail_blanking_image: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BurninDestinationSettings {
#[serde(rename = "Alignment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alignment: Option<String>,
#[serde(rename = "BackgroundColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub background_color: Option<String>,
#[serde(rename = "BackgroundOpacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub background_opacity: Option<i64>,
#[serde(rename = "FontColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_color: Option<String>,
#[serde(rename = "FontOpacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_opacity: Option<i64>,
#[serde(rename = "FontResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_resolution: Option<i64>,
#[serde(rename = "FontScript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_script: Option<String>,
#[serde(rename = "FontSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_size: Option<i64>,
#[serde(rename = "OutlineColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outline_color: Option<String>,
#[serde(rename = "OutlineSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outline_size: Option<i64>,
#[serde(rename = "ShadowColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_color: Option<String>,
#[serde(rename = "ShadowOpacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_opacity: Option<i64>,
#[serde(rename = "ShadowXOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_x_offset: Option<i64>,
#[serde(rename = "ShadowYOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_y_offset: Option<i64>,
#[serde(rename = "TeletextSpacing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub teletext_spacing: Option<String>,
#[serde(rename = "XPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_position: Option<i64>,
#[serde(rename = "YPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub y_position: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CancelJobRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CancelJobResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CaptionDescription {
#[serde(rename = "CaptionSelectorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_selector_name: Option<String>,
#[serde(rename = "CustomLanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_language_code: Option<String>,
#[serde(rename = "DestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_settings: Option<CaptionDestinationSettings>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_description: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CaptionDescriptionPreset {
#[serde(rename = "CustomLanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_language_code: Option<String>,
#[serde(rename = "DestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_settings: Option<CaptionDestinationSettings>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_description: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CaptionDestinationSettings {
#[serde(rename = "BurninDestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub burnin_destination_settings: Option<BurninDestinationSettings>,
#[serde(rename = "DestinationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_type: Option<String>,
#[serde(rename = "DvbSubDestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_sub_destination_settings: Option<DvbSubDestinationSettings>,
#[serde(rename = "EmbeddedDestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub embedded_destination_settings: Option<EmbeddedDestinationSettings>,
#[serde(rename = "SccDestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scc_destination_settings: Option<SccDestinationSettings>,
#[serde(rename = "TeletextDestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub teletext_destination_settings: Option<TeletextDestinationSettings>,
#[serde(rename = "TtmlDestinationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ttml_destination_settings: Option<TtmlDestinationSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CaptionSelector {
#[serde(rename = "CustomLanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_language_code: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "SourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_settings: Option<CaptionSourceSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CaptionSourceSettings {
#[serde(rename = "AncillarySourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ancillary_source_settings: Option<AncillarySourceSettings>,
#[serde(rename = "DvbSubSourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_sub_source_settings: Option<DvbSubSourceSettings>,
#[serde(rename = "EmbeddedSourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub embedded_source_settings: Option<EmbeddedSourceSettings>,
#[serde(rename = "FileSourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_source_settings: Option<FileSourceSettings>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "TeletextSourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub teletext_source_settings: Option<TeletextSourceSettings>,
#[serde(rename = "TrackSourceSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub track_source_settings: Option<TrackSourceSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ChannelMapping {
#[serde(rename = "OutputChannels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_channels: Option<Vec<OutputChannelMapping>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CmafEncryptionSettings {
#[serde(rename = "ConstantInitializationVector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constant_initialization_vector: Option<String>,
#[serde(rename = "EncryptionMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_method: Option<String>,
#[serde(rename = "InitializationVectorInManifest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initialization_vector_in_manifest: Option<String>,
#[serde(rename = "StaticKeyProvider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub static_key_provider: Option<StaticKeyProvider>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CmafGroupSettings {
#[serde(rename = "BaseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_url: Option<String>,
#[serde(rename = "ClientCache")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_cache: Option<String>,
#[serde(rename = "CodecSpecification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_specification: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<CmafEncryptionSettings>,
#[serde(rename = "FragmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fragment_length: Option<i64>,
#[serde(rename = "ManifestCompression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_compression: Option<String>,
#[serde(rename = "ManifestDurationFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_duration_format: Option<String>,
#[serde(rename = "MinBufferTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_buffer_time: Option<i64>,
#[serde(rename = "MinFinalSegmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_final_segment_length: Option<f64>,
#[serde(rename = "SegmentControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_control: Option<String>,
#[serde(rename = "SegmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_length: Option<i64>,
#[serde(rename = "StreamInfResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_inf_resolution: Option<String>,
#[serde(rename = "WriteDashManifest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_dash_manifest: Option<String>,
#[serde(rename = "WriteHlsManifest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_hls_manifest: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ColorCorrector {
#[serde(rename = "Brightness")]
#[serde(skip_serializing_if = "Option::is_none")]
pub brightness: Option<i64>,
#[serde(rename = "ColorSpaceConversion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub color_space_conversion: Option<String>,
#[serde(rename = "Contrast")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contrast: Option<i64>,
#[serde(rename = "Hdr10Metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hdr_10_metadata: Option<Hdr10Metadata>,
#[serde(rename = "Hue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hue: Option<i64>,
#[serde(rename = "Saturation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub saturation: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ContainerSettings {
#[serde(rename = "Container")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container: Option<String>,
#[serde(rename = "F4vSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub f_4v_settings: Option<F4vSettings>,
#[serde(rename = "M2tsSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub m_2ts_settings: Option<M2tsSettings>,
#[serde(rename = "M3u8Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub m_3u_8_settings: Option<M3u8Settings>,
#[serde(rename = "MovSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mov_settings: Option<MovSettings>,
#[serde(rename = "Mp4Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mp_4_settings: Option<Mp4Settings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateJobRequest {
#[serde(rename = "AccelerationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acceleration_settings: Option<AccelerationSettings>,
#[serde(rename = "BillingTagsSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_tags_source: Option<String>,
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "JobTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_template: Option<String>,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<String>,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "Settings")]
pub settings: JobSettings,
#[serde(rename = "UserMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_metadata: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateJobResponse {
#[serde(rename = "Job")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job: Option<Job>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateJobTemplateRequest {
#[serde(rename = "AccelerationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acceleration_settings: Option<AccelerationSettings>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<String>,
#[serde(rename = "Settings")]
pub settings: JobTemplateSettings,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateJobTemplateResponse {
#[serde(rename = "JobTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_template: Option<JobTemplate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreatePresetRequest {
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Settings")]
pub settings: PresetSettings,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreatePresetResponse {
#[serde(rename = "Preset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preset: Option<Preset>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateQueueRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "PricingPlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pricing_plan: Option<String>,
#[serde(rename = "ReservationPlanSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reservation_plan_settings: Option<ReservationPlanSettings>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateQueueResponse {
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<Queue>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DashIsoEncryptionSettings {
#[serde(rename = "SpekeKeyProvider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speke_key_provider: Option<SpekeKeyProvider>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DashIsoGroupSettings {
#[serde(rename = "BaseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_url: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<DashIsoEncryptionSettings>,
#[serde(rename = "FragmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fragment_length: Option<i64>,
#[serde(rename = "HbbtvCompliance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hbbtv_compliance: Option<String>,
#[serde(rename = "MinBufferTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_buffer_time: Option<i64>,
#[serde(rename = "SegmentControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_control: Option<String>,
#[serde(rename = "SegmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_length: Option<i64>,
#[serde(rename = "WriteSegmentTimelineInRepresentation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_segment_timeline_in_representation: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Deinterlacer {
#[serde(rename = "Algorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm: Option<String>,
#[serde(rename = "Control")]
#[serde(skip_serializing_if = "Option::is_none")]
pub control: Option<String>,
#[serde(rename = "Mode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteJobTemplateRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteJobTemplateResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeletePresetRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeletePresetResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteQueueRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteQueueResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEndpointsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Mode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEndpointsResponse {
#[serde(rename = "Endpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoints: Option<Vec<Endpoint>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateCertificateRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateCertificateResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DvbNitSettings {
#[serde(rename = "NetworkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_id: Option<i64>,
#[serde(rename = "NetworkName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_name: Option<String>,
#[serde(rename = "NitInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nit_interval: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DvbSdtSettings {
#[serde(rename = "OutputSdt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_sdt: Option<String>,
#[serde(rename = "SdtInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sdt_interval: Option<i64>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
#[serde(rename = "ServiceProviderName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_provider_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DvbSubDestinationSettings {
#[serde(rename = "Alignment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alignment: Option<String>,
#[serde(rename = "BackgroundColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub background_color: Option<String>,
#[serde(rename = "BackgroundOpacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub background_opacity: Option<i64>,
#[serde(rename = "FontColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_color: Option<String>,
#[serde(rename = "FontOpacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_opacity: Option<i64>,
#[serde(rename = "FontResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_resolution: Option<i64>,
#[serde(rename = "FontScript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_script: Option<String>,
#[serde(rename = "FontSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_size: Option<i64>,
#[serde(rename = "OutlineColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outline_color: Option<String>,
#[serde(rename = "OutlineSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outline_size: Option<i64>,
#[serde(rename = "ShadowColor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_color: Option<String>,
#[serde(rename = "ShadowOpacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_opacity: Option<i64>,
#[serde(rename = "ShadowXOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_x_offset: Option<i64>,
#[serde(rename = "ShadowYOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shadow_y_offset: Option<i64>,
#[serde(rename = "TeletextSpacing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub teletext_spacing: Option<String>,
#[serde(rename = "XPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_position: Option<i64>,
#[serde(rename = "YPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub y_position: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DvbSubSourceSettings {
#[serde(rename = "Pid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pid: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DvbTdtSettings {
#[serde(rename = "TdtInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tdt_interval: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Eac3Settings {
#[serde(rename = "AttenuationControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attenuation_control: Option<String>,
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "BitstreamMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitstream_mode: Option<String>,
#[serde(rename = "CodingMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub coding_mode: Option<String>,
#[serde(rename = "DcFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dc_filter: Option<String>,
#[serde(rename = "Dialnorm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dialnorm: Option<i64>,
#[serde(rename = "DynamicRangeCompressionLine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_range_compression_line: Option<String>,
#[serde(rename = "DynamicRangeCompressionRf")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_range_compression_rf: Option<String>,
#[serde(rename = "LfeControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lfe_control: Option<String>,
#[serde(rename = "LfeFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lfe_filter: Option<String>,
#[serde(rename = "LoRoCenterMixLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lo_ro_center_mix_level: Option<f64>,
#[serde(rename = "LoRoSurroundMixLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lo_ro_surround_mix_level: Option<f64>,
#[serde(rename = "LtRtCenterMixLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lt_rt_center_mix_level: Option<f64>,
#[serde(rename = "LtRtSurroundMixLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lt_rt_surround_mix_level: Option<f64>,
#[serde(rename = "MetadataControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata_control: Option<String>,
#[serde(rename = "PassthroughControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_control: Option<String>,
#[serde(rename = "PhaseControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phase_control: Option<String>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<i64>,
#[serde(rename = "StereoDownmix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stereo_downmix: Option<String>,
#[serde(rename = "SurroundExMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub surround_ex_mode: Option<String>,
#[serde(rename = "SurroundMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub surround_mode: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EmbeddedDestinationSettings {
#[serde(rename = "Destination608ChannelNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_608_channel_number: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EmbeddedSourceSettings {
#[serde(rename = "Convert608To708")]
#[serde(skip_serializing_if = "Option::is_none")]
pub convert_608_to_708: Option<String>,
#[serde(rename = "Source608ChannelNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_608_channel_number: Option<i64>,
#[serde(rename = "Source608TrackNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_608_track_number: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Endpoint {
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExceptionBody {
pub message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct F4vSettings {
#[serde(rename = "MoovPlacement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub moov_placement: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileGroupSettings {
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileSourceSettings {
#[serde(rename = "Convert608To708")]
#[serde(skip_serializing_if = "Option::is_none")]
pub convert_608_to_708: Option<String>,
#[serde(rename = "SourceFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_file: Option<String>,
#[serde(rename = "TimeDelta")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_delta: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FrameCaptureSettings {
#[serde(rename = "FramerateDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_denominator: Option<i64>,
#[serde(rename = "FramerateNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_numerator: Option<i64>,
#[serde(rename = "MaxCaptures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_captures: Option<i64>,
#[serde(rename = "Quality")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quality: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobResponse {
#[serde(rename = "Job")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job: Option<Job>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobTemplateRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobTemplateResponse {
#[serde(rename = "JobTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_template: Option<JobTemplate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetPresetRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetPresetResponse {
#[serde(rename = "Preset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preset: Option<Preset>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetQueueRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetQueueResponse {
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<Queue>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct H264QvbrSettings {
#[serde(rename = "MaxAverageBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_average_bitrate: Option<i64>,
#[serde(rename = "QvbrQualityLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qvbr_quality_level: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct H264Settings {
#[serde(rename = "AdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub adaptive_quantization: Option<String>,
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "CodecLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_level: Option<String>,
#[serde(rename = "CodecProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_profile: Option<String>,
#[serde(rename = "DynamicSubGop")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_sub_gop: Option<String>,
#[serde(rename = "EntropyEncoding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entropy_encoding: Option<String>,
#[serde(rename = "FieldEncoding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_encoding: Option<String>,
#[serde(rename = "FlickerAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flicker_adaptive_quantization: Option<String>,
#[serde(rename = "FramerateControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_control: Option<String>,
#[serde(rename = "FramerateConversionAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_conversion_algorithm: Option<String>,
#[serde(rename = "FramerateDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_denominator: Option<i64>,
#[serde(rename = "FramerateNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_numerator: Option<i64>,
#[serde(rename = "GopBReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_b_reference: Option<String>,
#[serde(rename = "GopClosedCadence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_closed_cadence: Option<i64>,
#[serde(rename = "GopSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_size: Option<f64>,
#[serde(rename = "GopSizeUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_size_units: Option<String>,
#[serde(rename = "HrdBufferInitialFillPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hrd_buffer_initial_fill_percentage: Option<i64>,
#[serde(rename = "HrdBufferSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hrd_buffer_size: Option<i64>,
#[serde(rename = "InterlaceMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interlace_mode: Option<String>,
#[serde(rename = "MaxBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_bitrate: Option<i64>,
#[serde(rename = "MinIInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_i_interval: Option<i64>,
#[serde(rename = "NumberBFramesBetweenReferenceFrames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_b_frames_between_reference_frames: Option<i64>,
#[serde(rename = "NumberReferenceFrames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_reference_frames: Option<i64>,
#[serde(rename = "ParControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_control: Option<String>,
#[serde(rename = "ParDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_denominator: Option<i64>,
#[serde(rename = "ParNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_numerator: Option<i64>,
#[serde(rename = "QualityTuningLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quality_tuning_level: Option<String>,
#[serde(rename = "QvbrSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qvbr_settings: Option<H264QvbrSettings>,
#[serde(rename = "RateControlMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rate_control_mode: Option<String>,
#[serde(rename = "RepeatPps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repeat_pps: Option<String>,
#[serde(rename = "SceneChangeDetect")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scene_change_detect: Option<String>,
#[serde(rename = "Slices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slices: Option<i64>,
#[serde(rename = "SlowPal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slow_pal: Option<String>,
#[serde(rename = "Softness")]
#[serde(skip_serializing_if = "Option::is_none")]
pub softness: Option<i64>,
#[serde(rename = "SpatialAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spatial_adaptive_quantization: Option<String>,
#[serde(rename = "Syntax")]
#[serde(skip_serializing_if = "Option::is_none")]
pub syntax: Option<String>,
#[serde(rename = "Telecine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub telecine: Option<String>,
#[serde(rename = "TemporalAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporal_adaptive_quantization: Option<String>,
#[serde(rename = "UnregisteredSeiTimecode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unregistered_sei_timecode: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct H265QvbrSettings {
#[serde(rename = "MaxAverageBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_average_bitrate: Option<i64>,
#[serde(rename = "QvbrQualityLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qvbr_quality_level: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct H265Settings {
#[serde(rename = "AdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub adaptive_quantization: Option<String>,
#[serde(rename = "AlternateTransferFunctionSei")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alternate_transfer_function_sei: Option<String>,
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "CodecLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_level: Option<String>,
#[serde(rename = "CodecProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_profile: Option<String>,
#[serde(rename = "DynamicSubGop")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_sub_gop: Option<String>,
#[serde(rename = "FlickerAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flicker_adaptive_quantization: Option<String>,
#[serde(rename = "FramerateControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_control: Option<String>,
#[serde(rename = "FramerateConversionAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_conversion_algorithm: Option<String>,
#[serde(rename = "FramerateDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_denominator: Option<i64>,
#[serde(rename = "FramerateNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_numerator: Option<i64>,
#[serde(rename = "GopBReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_b_reference: Option<String>,
#[serde(rename = "GopClosedCadence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_closed_cadence: Option<i64>,
#[serde(rename = "GopSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_size: Option<f64>,
#[serde(rename = "GopSizeUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_size_units: Option<String>,
#[serde(rename = "HrdBufferInitialFillPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hrd_buffer_initial_fill_percentage: Option<i64>,
#[serde(rename = "HrdBufferSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hrd_buffer_size: Option<i64>,
#[serde(rename = "InterlaceMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interlace_mode: Option<String>,
#[serde(rename = "MaxBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_bitrate: Option<i64>,
#[serde(rename = "MinIInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_i_interval: Option<i64>,
#[serde(rename = "NumberBFramesBetweenReferenceFrames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_b_frames_between_reference_frames: Option<i64>,
#[serde(rename = "NumberReferenceFrames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_reference_frames: Option<i64>,
#[serde(rename = "ParControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_control: Option<String>,
#[serde(rename = "ParDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_denominator: Option<i64>,
#[serde(rename = "ParNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_numerator: Option<i64>,
#[serde(rename = "QualityTuningLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quality_tuning_level: Option<String>,
#[serde(rename = "QvbrSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qvbr_settings: Option<H265QvbrSettings>,
#[serde(rename = "RateControlMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rate_control_mode: Option<String>,
#[serde(rename = "SampleAdaptiveOffsetFilterMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_adaptive_offset_filter_mode: Option<String>,
#[serde(rename = "SceneChangeDetect")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scene_change_detect: Option<String>,
#[serde(rename = "Slices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slices: Option<i64>,
#[serde(rename = "SlowPal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slow_pal: Option<String>,
#[serde(rename = "SpatialAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spatial_adaptive_quantization: Option<String>,
#[serde(rename = "Telecine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub telecine: Option<String>,
#[serde(rename = "TemporalAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporal_adaptive_quantization: Option<String>,
#[serde(rename = "TemporalIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporal_ids: Option<String>,
#[serde(rename = "Tiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tiles: Option<String>,
#[serde(rename = "UnregisteredSeiTimecode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unregistered_sei_timecode: Option<String>,
#[serde(rename = "WriteMp4PackagingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_mp_4_packaging_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Hdr10Metadata {
#[serde(rename = "BluePrimaryX")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blue_primary_x: Option<i64>,
#[serde(rename = "BluePrimaryY")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blue_primary_y: Option<i64>,
#[serde(rename = "GreenPrimaryX")]
#[serde(skip_serializing_if = "Option::is_none")]
pub green_primary_x: Option<i64>,
#[serde(rename = "GreenPrimaryY")]
#[serde(skip_serializing_if = "Option::is_none")]
pub green_primary_y: Option<i64>,
#[serde(rename = "MaxContentLightLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_content_light_level: Option<i64>,
#[serde(rename = "MaxFrameAverageLightLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_frame_average_light_level: Option<i64>,
#[serde(rename = "MaxLuminance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_luminance: Option<i64>,
#[serde(rename = "MinLuminance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_luminance: Option<i64>,
#[serde(rename = "RedPrimaryX")]
#[serde(skip_serializing_if = "Option::is_none")]
pub red_primary_x: Option<i64>,
#[serde(rename = "RedPrimaryY")]
#[serde(skip_serializing_if = "Option::is_none")]
pub red_primary_y: Option<i64>,
#[serde(rename = "WhitePointX")]
#[serde(skip_serializing_if = "Option::is_none")]
pub white_point_x: Option<i64>,
#[serde(rename = "WhitePointY")]
#[serde(skip_serializing_if = "Option::is_none")]
pub white_point_y: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HlsCaptionLanguageMapping {
#[serde(rename = "CaptionChannel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_channel: Option<i64>,
#[serde(rename = "CustomLanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_language_code: Option<String>,
#[serde(rename = "LanguageCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_code: Option<String>,
#[serde(rename = "LanguageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language_description: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HlsEncryptionSettings {
#[serde(rename = "ConstantInitializationVector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constant_initialization_vector: Option<String>,
#[serde(rename = "EncryptionMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_method: Option<String>,
#[serde(rename = "InitializationVectorInManifest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initialization_vector_in_manifest: Option<String>,
#[serde(rename = "SpekeKeyProvider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speke_key_provider: Option<SpekeKeyProvider>,
#[serde(rename = "StaticKeyProvider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub static_key_provider: Option<StaticKeyProvider>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HlsGroupSettings {
#[serde(rename = "AdMarkers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_markers: Option<Vec<String>>,
#[serde(rename = "BaseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_url: Option<String>,
#[serde(rename = "CaptionLanguageMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_language_mappings: Option<Vec<HlsCaptionLanguageMapping>>,
#[serde(rename = "CaptionLanguageSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_language_setting: Option<String>,
#[serde(rename = "ClientCache")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_cache: Option<String>,
#[serde(rename = "CodecSpecification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_specification: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "DirectoryStructure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_structure: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<HlsEncryptionSettings>,
#[serde(rename = "ManifestCompression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_compression: Option<String>,
#[serde(rename = "ManifestDurationFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_duration_format: Option<String>,
#[serde(rename = "MinFinalSegmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_final_segment_length: Option<f64>,
#[serde(rename = "MinSegmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_segment_length: Option<i64>,
#[serde(rename = "OutputSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_selection: Option<String>,
#[serde(rename = "ProgramDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_date_time: Option<String>,
#[serde(rename = "ProgramDateTimePeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_date_time_period: Option<i64>,
#[serde(rename = "SegmentControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_control: Option<String>,
#[serde(rename = "SegmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_length: Option<i64>,
#[serde(rename = "SegmentsPerSubdirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segments_per_subdirectory: Option<i64>,
#[serde(rename = "StreamInfResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_inf_resolution: Option<String>,
#[serde(rename = "TimedMetadataId3Frame")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata_id_3_frame: Option<String>,
#[serde(rename = "TimedMetadataId3Period")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata_id_3_period: Option<i64>,
#[serde(rename = "TimestampDeltaMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp_delta_milliseconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HlsSettings {
#[serde(rename = "AudioGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_group_id: Option<String>,
#[serde(rename = "AudioRenditionSets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_rendition_sets: Option<String>,
#[serde(rename = "AudioTrackType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_track_type: Option<String>,
#[serde(rename = "IFrameOnlyManifest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub i_frame_only_manifest: Option<String>,
#[serde(rename = "SegmentModifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_modifier: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Id3Insertion {
#[serde(rename = "Id3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_3: Option<String>,
#[serde(rename = "Timecode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImageInserter {
#[serde(rename = "InsertableImages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub insertable_images: Option<Vec<InsertableImage>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Input {
#[serde(rename = "AudioSelectorGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_selector_groups: Option<::std::collections::HashMap<String, AudioSelectorGroup>>,
#[serde(rename = "AudioSelectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_selectors: Option<::std::collections::HashMap<String, AudioSelector>>,
#[serde(rename = "CaptionSelectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_selectors: Option<::std::collections::HashMap<String, CaptionSelector>>,
#[serde(rename = "DeblockFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deblock_filter: Option<String>,
#[serde(rename = "DecryptionSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub decryption_settings: Option<InputDecryptionSettings>,
#[serde(rename = "DenoiseFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub denoise_filter: Option<String>,
#[serde(rename = "FileInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_input: Option<String>,
#[serde(rename = "FilterEnable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_enable: Option<String>,
#[serde(rename = "FilterStrength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_strength: Option<i64>,
#[serde(rename = "ImageInserter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_inserter: Option<ImageInserter>,
#[serde(rename = "InputClippings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_clippings: Option<Vec<InputClipping>>,
#[serde(rename = "ProgramNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_number: Option<i64>,
#[serde(rename = "PsiControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub psi_control: Option<String>,
#[serde(rename = "SupplementalImps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supplemental_imps: Option<Vec<String>>,
#[serde(rename = "TimecodeSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode_source: Option<String>,
#[serde(rename = "VideoSelector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_selector: Option<VideoSelector>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputClipping {
#[serde(rename = "EndTimecode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_timecode: Option<String>,
#[serde(rename = "StartTimecode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_timecode: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputDecryptionSettings {
#[serde(rename = "DecryptionMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub decryption_mode: Option<String>,
#[serde(rename = "EncryptedDecryptionKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted_decryption_key: Option<String>,
#[serde(rename = "InitializationVector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initialization_vector: Option<String>,
#[serde(rename = "KmsKeyRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_region: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputTemplate {
#[serde(rename = "AudioSelectorGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_selector_groups: Option<::std::collections::HashMap<String, AudioSelectorGroup>>,
#[serde(rename = "AudioSelectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_selectors: Option<::std::collections::HashMap<String, AudioSelector>>,
#[serde(rename = "CaptionSelectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_selectors: Option<::std::collections::HashMap<String, CaptionSelector>>,
#[serde(rename = "DeblockFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deblock_filter: Option<String>,
#[serde(rename = "DenoiseFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub denoise_filter: Option<String>,
#[serde(rename = "FilterEnable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_enable: Option<String>,
#[serde(rename = "FilterStrength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_strength: Option<i64>,
#[serde(rename = "ImageInserter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_inserter: Option<ImageInserter>,
#[serde(rename = "InputClippings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_clippings: Option<Vec<InputClipping>>,
#[serde(rename = "ProgramNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_number: Option<i64>,
#[serde(rename = "PsiControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub psi_control: Option<String>,
#[serde(rename = "TimecodeSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode_source: Option<String>,
#[serde(rename = "VideoSelector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_selector: Option<VideoSelector>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InsertableImage {
#[serde(rename = "Duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
#[serde(rename = "FadeIn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fade_in: Option<i64>,
#[serde(rename = "FadeOut")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fade_out: Option<i64>,
#[serde(rename = "Height")]
#[serde(skip_serializing_if = "Option::is_none")]
pub height: Option<i64>,
#[serde(rename = "ImageInserterInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_inserter_input: Option<String>,
#[serde(rename = "ImageX")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_x: Option<i64>,
#[serde(rename = "ImageY")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_y: Option<i64>,
#[serde(rename = "Layer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer: Option<i64>,
#[serde(rename = "Opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub opacity: Option<i64>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<String>,
#[serde(rename = "Width")]
#[serde(skip_serializing_if = "Option::is_none")]
pub width: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Job {
#[serde(rename = "AccelerationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acceleration_settings: Option<AccelerationSettings>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "BillingTagsSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_tags_source: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<i64>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "JobTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_template: Option<String>,
#[serde(rename = "OutputGroupDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_group_details: Option<Vec<OutputGroupDetail>>,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<String>,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "Settings")]
pub settings: JobSettings,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Timing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timing: Option<Timing>,
#[serde(rename = "UserMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_metadata: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JobSettings {
#[serde(rename = "AdAvailOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_avail_offset: Option<i64>,
#[serde(rename = "AvailBlanking")]
#[serde(skip_serializing_if = "Option::is_none")]
pub avail_blanking: Option<AvailBlanking>,
#[serde(rename = "Inputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inputs: Option<Vec<Input>>,
#[serde(rename = "MotionImageInserter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub motion_image_inserter: Option<MotionImageInserter>,
#[serde(rename = "NielsenConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nielsen_configuration: Option<NielsenConfiguration>,
#[serde(rename = "OutputGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_groups: Option<Vec<OutputGroup>>,
#[serde(rename = "TimecodeConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode_config: Option<TimecodeConfig>,
#[serde(rename = "TimedMetadataInsertion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata_insertion: Option<TimedMetadataInsertion>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JobTemplate {
#[serde(rename = "AccelerationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acceleration_settings: Option<AccelerationSettings>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<String>,
#[serde(rename = "Settings")]
pub settings: JobTemplateSettings,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JobTemplateSettings {
#[serde(rename = "AdAvailOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_avail_offset: Option<i64>,
#[serde(rename = "AvailBlanking")]
#[serde(skip_serializing_if = "Option::is_none")]
pub avail_blanking: Option<AvailBlanking>,
#[serde(rename = "Inputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inputs: Option<Vec<InputTemplate>>,
#[serde(rename = "MotionImageInserter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub motion_image_inserter: Option<MotionImageInserter>,
#[serde(rename = "NielsenConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nielsen_configuration: Option<NielsenConfiguration>,
#[serde(rename = "OutputGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_groups: Option<Vec<OutputGroup>>,
#[serde(rename = "TimecodeConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode_config: Option<TimecodeConfig>,
#[serde(rename = "TimedMetadataInsertion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata_insertion: Option<TimedMetadataInsertion>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListJobTemplatesRequest {
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "ListBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_by: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Order")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListJobTemplatesResponse {
#[serde(rename = "JobTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_templates: Option<Vec<JobTemplate>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListJobsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Order")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order: Option<String>,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListJobsResponse {
#[serde(rename = "Jobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jobs: Option<Vec<Job>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListPresetsRequest {
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "ListBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_by: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Order")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListPresetsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Presets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub presets: Option<Vec<Preset>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListQueuesRequest {
#[serde(rename = "ListBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_by: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Order")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListQueuesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Queues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queues: Option<Vec<Queue>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsForResourceRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "ResourceTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_tags: Option<ResourceTags>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct M2tsSettings {
#[serde(rename = "AudioBufferModel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_buffer_model: Option<String>,
#[serde(rename = "AudioFramesPerPes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_frames_per_pes: Option<i64>,
#[serde(rename = "AudioPids")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_pids: Option<Vec<i64>>,
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "BufferModel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub buffer_model: Option<String>,
#[serde(rename = "DvbNitSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_nit_settings: Option<DvbNitSettings>,
#[serde(rename = "DvbSdtSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_sdt_settings: Option<DvbSdtSettings>,
#[serde(rename = "DvbSubPids")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_sub_pids: Option<Vec<i64>>,
#[serde(rename = "DvbTdtSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_tdt_settings: Option<DvbTdtSettings>,
#[serde(rename = "DvbTeletextPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dvb_teletext_pid: Option<i64>,
#[serde(rename = "EbpAudioInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebp_audio_interval: Option<String>,
#[serde(rename = "EbpPlacement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebp_placement: Option<String>,
#[serde(rename = "EsRateInPes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub es_rate_in_pes: Option<String>,
#[serde(rename = "ForceTsVideoEbpOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_ts_video_ebp_order: Option<String>,
#[serde(rename = "FragmentTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fragment_time: Option<f64>,
#[serde(rename = "MaxPcrInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_pcr_interval: Option<i64>,
#[serde(rename = "MinEbpInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_ebp_interval: Option<i64>,
#[serde(rename = "NielsenId3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nielsen_id_3: Option<String>,
#[serde(rename = "NullPacketBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub null_packet_bitrate: Option<f64>,
#[serde(rename = "PatInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pat_interval: Option<i64>,
#[serde(rename = "PcrControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pcr_control: Option<String>,
#[serde(rename = "PcrPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pcr_pid: Option<i64>,
#[serde(rename = "PmtInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pmt_interval: Option<i64>,
#[serde(rename = "PmtPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pmt_pid: Option<i64>,
#[serde(rename = "PrivateMetadataPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_metadata_pid: Option<i64>,
#[serde(rename = "ProgramNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_number: Option<i64>,
#[serde(rename = "RateMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rate_mode: Option<String>,
#[serde(rename = "Scte35Pid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scte_35_pid: Option<i64>,
#[serde(rename = "Scte35Source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scte_35_source: Option<String>,
#[serde(rename = "SegmentationMarkers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segmentation_markers: Option<String>,
#[serde(rename = "SegmentationStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segmentation_style: Option<String>,
#[serde(rename = "SegmentationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segmentation_time: Option<f64>,
#[serde(rename = "TimedMetadataPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata_pid: Option<i64>,
#[serde(rename = "TransportStreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transport_stream_id: Option<i64>,
#[serde(rename = "VideoPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_pid: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct M3u8Settings {
#[serde(rename = "AudioFramesPerPes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_frames_per_pes: Option<i64>,
#[serde(rename = "AudioPids")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_pids: Option<Vec<i64>>,
#[serde(rename = "NielsenId3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nielsen_id_3: Option<String>,
#[serde(rename = "PatInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pat_interval: Option<i64>,
#[serde(rename = "PcrControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pcr_control: Option<String>,
#[serde(rename = "PcrPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pcr_pid: Option<i64>,
#[serde(rename = "PmtInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pmt_interval: Option<i64>,
#[serde(rename = "PmtPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pmt_pid: Option<i64>,
#[serde(rename = "PrivateMetadataPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_metadata_pid: Option<i64>,
#[serde(rename = "ProgramNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_number: Option<i64>,
#[serde(rename = "Scte35Pid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scte_35_pid: Option<i64>,
#[serde(rename = "Scte35Source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scte_35_source: Option<String>,
#[serde(rename = "TimedMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata: Option<String>,
#[serde(rename = "TimedMetadataPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timed_metadata_pid: Option<i64>,
#[serde(rename = "TransportStreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transport_stream_id: Option<i64>,
#[serde(rename = "VideoPid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_pid: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MotionImageInserter {
#[serde(rename = "Framerate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate: Option<MotionImageInsertionFramerate>,
#[serde(rename = "Input")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input: Option<String>,
#[serde(rename = "InsertionMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub insertion_mode: Option<String>,
#[serde(rename = "Offset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offset: Option<MotionImageInsertionOffset>,
#[serde(rename = "Playback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MotionImageInsertionFramerate {
#[serde(rename = "FramerateDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_denominator: Option<i64>,
#[serde(rename = "FramerateNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_numerator: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MotionImageInsertionOffset {
#[serde(rename = "ImageX")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_x: Option<i64>,
#[serde(rename = "ImageY")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_y: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MovSettings {
#[serde(rename = "ClapAtom")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clap_atom: Option<String>,
#[serde(rename = "CslgAtom")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cslg_atom: Option<String>,
#[serde(rename = "Mpeg2FourCCControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mpeg_2_four_cc_control: Option<String>,
#[serde(rename = "PaddingControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub padding_control: Option<String>,
#[serde(rename = "Reference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Mp2Settings {
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "Channels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channels: Option<i64>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Mp4Settings {
#[serde(rename = "CslgAtom")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cslg_atom: Option<String>,
#[serde(rename = "FreeSpaceBox")]
#[serde(skip_serializing_if = "Option::is_none")]
pub free_space_box: Option<String>,
#[serde(rename = "MoovPlacement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub moov_placement: Option<String>,
#[serde(rename = "Mp4MajorBrand")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mp_4_major_brand: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Mpeg2Settings {
#[serde(rename = "AdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub adaptive_quantization: Option<String>,
#[serde(rename = "Bitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitrate: Option<i64>,
#[serde(rename = "CodecLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_level: Option<String>,
#[serde(rename = "CodecProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_profile: Option<String>,
#[serde(rename = "DynamicSubGop")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_sub_gop: Option<String>,
#[serde(rename = "FramerateControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_control: Option<String>,
#[serde(rename = "FramerateConversionAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_conversion_algorithm: Option<String>,
#[serde(rename = "FramerateDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_denominator: Option<i64>,
#[serde(rename = "FramerateNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_numerator: Option<i64>,
#[serde(rename = "GopClosedCadence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_closed_cadence: Option<i64>,
#[serde(rename = "GopSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_size: Option<f64>,
#[serde(rename = "GopSizeUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gop_size_units: Option<String>,
#[serde(rename = "HrdBufferInitialFillPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hrd_buffer_initial_fill_percentage: Option<i64>,
#[serde(rename = "HrdBufferSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hrd_buffer_size: Option<i64>,
#[serde(rename = "InterlaceMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interlace_mode: Option<String>,
#[serde(rename = "IntraDcPrecision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub intra_dc_precision: Option<String>,
#[serde(rename = "MaxBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_bitrate: Option<i64>,
#[serde(rename = "MinIInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_i_interval: Option<i64>,
#[serde(rename = "NumberBFramesBetweenReferenceFrames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_b_frames_between_reference_frames: Option<i64>,
#[serde(rename = "ParControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_control: Option<String>,
#[serde(rename = "ParDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_denominator: Option<i64>,
#[serde(rename = "ParNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_numerator: Option<i64>,
#[serde(rename = "QualityTuningLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quality_tuning_level: Option<String>,
#[serde(rename = "RateControlMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rate_control_mode: Option<String>,
#[serde(rename = "SceneChangeDetect")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scene_change_detect: Option<String>,
#[serde(rename = "SlowPal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slow_pal: Option<String>,
#[serde(rename = "Softness")]
#[serde(skip_serializing_if = "Option::is_none")]
pub softness: Option<i64>,
#[serde(rename = "SpatialAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spatial_adaptive_quantization: Option<String>,
#[serde(rename = "Syntax")]
#[serde(skip_serializing_if = "Option::is_none")]
pub syntax: Option<String>,
#[serde(rename = "Telecine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub telecine: Option<String>,
#[serde(rename = "TemporalAdaptiveQuantization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporal_adaptive_quantization: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MsSmoothEncryptionSettings {
#[serde(rename = "SpekeKeyProvider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speke_key_provider: Option<SpekeKeyProvider>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MsSmoothGroupSettings {
#[serde(rename = "AudioDeduplication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_deduplication: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<MsSmoothEncryptionSettings>,
#[serde(rename = "FragmentLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fragment_length: Option<i64>,
#[serde(rename = "ManifestEncoding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_encoding: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NielsenConfiguration {
#[serde(rename = "BreakoutCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub breakout_code: Option<i64>,
#[serde(rename = "DistributorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distributor_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NoiseReducer {
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<String>,
#[serde(rename = "FilterSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_settings: Option<NoiseReducerFilterSettings>,
#[serde(rename = "SpatialFilterSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spatial_filter_settings: Option<NoiseReducerSpatialFilterSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NoiseReducerFilterSettings {
#[serde(rename = "Strength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub strength: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NoiseReducerSpatialFilterSettings {
#[serde(rename = "PostFilterSharpenStrength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub post_filter_sharpen_strength: Option<i64>,
#[serde(rename = "Speed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub speed: Option<i64>,
#[serde(rename = "Strength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub strength: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Output {
#[serde(rename = "AudioDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_descriptions: Option<Vec<AudioDescription>>,
#[serde(rename = "CaptionDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_descriptions: Option<Vec<CaptionDescription>>,
#[serde(rename = "ContainerSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_settings: Option<ContainerSettings>,
#[serde(rename = "Extension")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extension: Option<String>,
#[serde(rename = "NameModifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_modifier: Option<String>,
#[serde(rename = "OutputSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_settings: Option<OutputSettings>,
#[serde(rename = "Preset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preset: Option<String>,
#[serde(rename = "VideoDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_description: Option<VideoDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutputChannelMapping {
#[serde(rename = "InputChannels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_channels: Option<Vec<i64>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OutputDetail {
#[serde(rename = "DurationInMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration_in_ms: Option<i64>,
#[serde(rename = "VideoDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_details: Option<VideoDetail>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutputGroup {
#[serde(rename = "CustomName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_name: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OutputGroupSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_group_settings: Option<OutputGroupSettings>,
#[serde(rename = "Outputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outputs: Option<Vec<Output>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OutputGroupDetail {
#[serde(rename = "OutputDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_details: Option<Vec<OutputDetail>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutputGroupSettings {
#[serde(rename = "CmafGroupSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cmaf_group_settings: Option<CmafGroupSettings>,
#[serde(rename = "DashIsoGroupSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_iso_group_settings: Option<DashIsoGroupSettings>,
#[serde(rename = "FileGroupSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_group_settings: Option<FileGroupSettings>,
#[serde(rename = "HlsGroupSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_group_settings: Option<HlsGroupSettings>,
#[serde(rename = "MsSmoothGroupSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ms_smooth_group_settings: Option<MsSmoothGroupSettings>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutputSettings {
#[serde(rename = "HlsSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_settings: Option<HlsSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Preset {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Settings")]
pub settings: PresetSettings,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PresetSettings {
#[serde(rename = "AudioDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audio_descriptions: Option<Vec<AudioDescription>>,
#[serde(rename = "CaptionDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caption_descriptions: Option<Vec<CaptionDescriptionPreset>>,
#[serde(rename = "ContainerSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_settings: Option<ContainerSettings>,
#[serde(rename = "VideoDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_description: Option<VideoDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProresSettings {
#[serde(rename = "CodecProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_profile: Option<String>,
#[serde(rename = "FramerateControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_control: Option<String>,
#[serde(rename = "FramerateConversionAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_conversion_algorithm: Option<String>,
#[serde(rename = "FramerateDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_denominator: Option<i64>,
#[serde(rename = "FramerateNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate_numerator: Option<i64>,
#[serde(rename = "InterlaceMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interlace_mode: Option<String>,
#[serde(rename = "ParControl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_control: Option<String>,
#[serde(rename = "ParDenominator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_denominator: Option<i64>,
#[serde(rename = "ParNumerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub par_numerator: Option<i64>,
#[serde(rename = "SlowPal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slow_pal: Option<String>,
#[serde(rename = "Telecine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub telecine: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Queue {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "PricingPlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pricing_plan: Option<String>,
#[serde(rename = "ProgressingJobsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progressing_jobs_count: Option<i64>,
#[serde(rename = "ReservationPlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reservation_plan: Option<ReservationPlan>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "SubmittedJobsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submitted_jobs_count: Option<i64>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Rectangle {
#[serde(rename = "Height")]
#[serde(skip_serializing_if = "Option::is_none")]
pub height: Option<i64>,
#[serde(rename = "Width")]
#[serde(skip_serializing_if = "Option::is_none")]
pub width: Option<i64>,
#[serde(rename = "X")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x: Option<i64>,
#[serde(rename = "Y")]
#[serde(skip_serializing_if = "Option::is_none")]
pub y: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RemixSettings {
#[serde(rename = "ChannelMapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_mapping: Option<ChannelMapping>,
#[serde(rename = "ChannelsIn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channels_in: Option<i64>,
#[serde(rename = "ChannelsOut")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channels_out: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReservationPlan {
#[serde(rename = "Commitment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commitment: Option<String>,
#[serde(rename = "ExpiresAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<f64>,
#[serde(rename = "PurchasedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub purchased_at: Option<f64>,
#[serde(rename = "RenewalType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_type: Option<String>,
#[serde(rename = "ReservedSlots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_slots: Option<i64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ReservationPlanSettings {
#[serde(rename = "Commitment")]
pub commitment: String,
#[serde(rename = "RenewalType")]
pub renewal_type: String,
#[serde(rename = "ReservedSlots")]
pub reserved_slots: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResourceTags {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SccDestinationSettings {
#[serde(rename = "Framerate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framerate: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SpekeKeyProvider {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "SystemIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub system_ids: Option<Vec<String>>,
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StaticKeyProvider {
#[serde(rename = "KeyFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_format: Option<String>,
#[serde(rename = "KeyFormatVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_format_versions: Option<String>,
#[serde(rename = "StaticKeyValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub static_key_value: Option<String>,
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TagResourceRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TeletextDestinationSettings {
#[serde(rename = "PageNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_number: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TeletextSourceSettings {
#[serde(rename = "PageNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_number: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TimecodeBurnin {
#[serde(rename = "FontSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub font_size: Option<i64>,
#[serde(rename = "Position")]
#[serde(skip_serializing_if = "Option::is_none")]
pub position: Option<String>,
#[serde(rename = "Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prefix: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TimecodeConfig {
#[serde(rename = "Anchor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub anchor: Option<String>,
#[serde(rename = "Source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[serde(rename = "Start")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start: Option<String>,
#[serde(rename = "TimestampOffset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp_offset: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TimedMetadataInsertion {
#[serde(rename = "Id3Insertions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_3_insertions: Option<Vec<Id3Insertion>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Timing {
#[serde(rename = "FinishTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finish_time: Option<f64>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "SubmitTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_time: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TrackSourceSettings {
#[serde(rename = "TrackNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub track_number: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TtmlDestinationSettings {
#[serde(rename = "StylePassthrough")]
#[serde(skip_serializing_if = "Option::is_none")]
pub style_passthrough: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UntagResourceRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "TagKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_keys: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateJobTemplateRequest {
#[serde(rename = "AccelerationSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acceleration_settings: Option<AccelerationSettings>,
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<String>,
#[serde(rename = "Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<JobTemplateSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateJobTemplateResponse {
#[serde(rename = "JobTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_template: Option<JobTemplate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdatePresetRequest {
#[serde(rename = "Category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<PresetSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdatePresetResponse {
#[serde(rename = "Preset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preset: Option<Preset>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateQueueRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ReservationPlanSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reservation_plan_settings: Option<ReservationPlanSettings>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateQueueResponse {
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<Queue>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VideoCodecSettings {
#[serde(rename = "Codec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec: Option<String>,
#[serde(rename = "FrameCaptureSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frame_capture_settings: Option<FrameCaptureSettings>,
#[serde(rename = "H264Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub h264_settings: Option<H264Settings>,
#[serde(rename = "H265Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub h265_settings: Option<H265Settings>,
#[serde(rename = "Mpeg2Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mpeg_2_settings: Option<Mpeg2Settings>,
#[serde(rename = "ProresSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prores_settings: Option<ProresSettings>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VideoDescription {
#[serde(rename = "AfdSignaling")]
#[serde(skip_serializing_if = "Option::is_none")]
pub afd_signaling: Option<String>,
#[serde(rename = "AntiAlias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub anti_alias: Option<String>,
#[serde(rename = "CodecSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub codec_settings: Option<VideoCodecSettings>,
#[serde(rename = "ColorMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub color_metadata: Option<String>,
#[serde(rename = "Crop")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crop: Option<Rectangle>,
#[serde(rename = "DropFrameTimecode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub drop_frame_timecode: Option<String>,
#[serde(rename = "FixedAfd")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fixed_afd: Option<i64>,
#[serde(rename = "Height")]
#[serde(skip_serializing_if = "Option::is_none")]
pub height: Option<i64>,
#[serde(rename = "Position")]
#[serde(skip_serializing_if = "Option::is_none")]
pub position: Option<Rectangle>,
#[serde(rename = "RespondToAfd")]
#[serde(skip_serializing_if = "Option::is_none")]
pub respond_to_afd: Option<String>,
#[serde(rename = "ScalingBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scaling_behavior: Option<String>,
#[serde(rename = "Sharpness")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sharpness: Option<i64>,
#[serde(rename = "TimecodeInsertion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode_insertion: Option<String>,
#[serde(rename = "VideoPreprocessors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_preprocessors: Option<VideoPreprocessor>,
#[serde(rename = "Width")]
#[serde(skip_serializing_if = "Option::is_none")]
pub width: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct VideoDetail {
#[serde(rename = "HeightInPx")]
#[serde(skip_serializing_if = "Option::is_none")]
pub height_in_px: Option<i64>,
#[serde(rename = "WidthInPx")]
#[serde(skip_serializing_if = "Option::is_none")]
pub width_in_px: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VideoPreprocessor {
#[serde(rename = "ColorCorrector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub color_corrector: Option<ColorCorrector>,
#[serde(rename = "Deinterlacer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deinterlacer: Option<Deinterlacer>,
#[serde(rename = "ImageInserter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_inserter: Option<ImageInserter>,
#[serde(rename = "NoiseReducer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub noise_reducer: Option<NoiseReducer>,
#[serde(rename = "TimecodeBurnin")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timecode_burnin: Option<TimecodeBurnin>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VideoSelector {
#[serde(rename = "ColorSpace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub color_space: Option<String>,
#[serde(rename = "ColorSpaceUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub color_space_usage: Option<String>,
#[serde(rename = "Hdr10Metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hdr_10_metadata: Option<Hdr10Metadata>,
#[serde(rename = "Pid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pid: Option<i64>,
#[serde(rename = "ProgramNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_number: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WavSettings {
#[serde(rename = "BitDepth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bit_depth: Option<i64>,
#[serde(rename = "Channels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channels: Option<i64>,
#[serde(rename = "Format")]
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
#[serde(rename = "SampleRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_rate: Option<i64>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateCertificateError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateCertificateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return AssociateCertificateError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return AssociateCertificateError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return AssociateCertificateError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return AssociateCertificateError::InternalServerError(String::from(
error_message,
));
}
"NotFoundException" => {
return AssociateCertificateError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return AssociateCertificateError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return AssociateCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateCertificateError {
fn from(err: serde_json::error::Error) -> AssociateCertificateError {
AssociateCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateCertificateError {
fn from(err: CredentialsError) -> AssociateCertificateError {
AssociateCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateCertificateError {
fn from(err: HttpDispatchError) -> AssociateCertificateError {
AssociateCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateCertificateError {
fn from(err: io::Error) -> AssociateCertificateError {
AssociateCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateCertificateError {
fn description(&self) -> &str {
match *self {
AssociateCertificateError::BadRequest(ref cause) => cause,
AssociateCertificateError::Conflict(ref cause) => cause,
AssociateCertificateError::Forbidden(ref cause) => cause,
AssociateCertificateError::InternalServerError(ref cause) => cause,
AssociateCertificateError::NotFound(ref cause) => cause,
AssociateCertificateError::TooManyRequests(ref cause) => cause,
AssociateCertificateError::Validation(ref cause) => cause,
AssociateCertificateError::Credentials(ref err) => err.description(),
AssociateCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateCertificateError::ParseError(ref cause) => cause,
AssociateCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelJobError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CancelJobError {
pub fn from_response(res: BufferedHttpResponse) -> CancelJobError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CancelJobError::BadRequest(String::from(error_message));
}
"ConflictException" => return CancelJobError::Conflict(String::from(error_message)),
"ForbiddenException" => {
return CancelJobError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return CancelJobError::InternalServerError(String::from(error_message));
}
"NotFoundException" => return CancelJobError::NotFound(String::from(error_message)),
"TooManyRequestsException" => {
return CancelJobError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return CancelJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return CancelJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CancelJobError {
fn from(err: serde_json::error::Error) -> CancelJobError {
CancelJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CancelJobError {
fn from(err: CredentialsError) -> CancelJobError {
CancelJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for CancelJobError {
fn from(err: HttpDispatchError) -> CancelJobError {
CancelJobError::HttpDispatch(err)
}
}
impl From<io::Error> for CancelJobError {
fn from(err: io::Error) -> CancelJobError {
CancelJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CancelJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelJobError {
fn description(&self) -> &str {
match *self {
CancelJobError::BadRequest(ref cause) => cause,
CancelJobError::Conflict(ref cause) => cause,
CancelJobError::Forbidden(ref cause) => cause,
CancelJobError::InternalServerError(ref cause) => cause,
CancelJobError::NotFound(ref cause) => cause,
CancelJobError::TooManyRequests(ref cause) => cause,
CancelJobError::Validation(ref cause) => cause,
CancelJobError::Credentials(ref err) => err.description(),
CancelJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CancelJobError::ParseError(ref cause) => cause,
CancelJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateJobError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateJobError {
pub fn from_response(res: BufferedHttpResponse) -> CreateJobError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateJobError::BadRequest(String::from(error_message));
}
"ConflictException" => return CreateJobError::Conflict(String::from(error_message)),
"ForbiddenException" => {
return CreateJobError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return CreateJobError::InternalServerError(String::from(error_message));
}
"NotFoundException" => return CreateJobError::NotFound(String::from(error_message)),
"TooManyRequestsException" => {
return CreateJobError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return CreateJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateJobError {
fn from(err: serde_json::error::Error) -> CreateJobError {
CreateJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateJobError {
fn from(err: CredentialsError) -> CreateJobError {
CreateJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateJobError {
fn from(err: HttpDispatchError) -> CreateJobError {
CreateJobError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateJobError {
fn from(err: io::Error) -> CreateJobError {
CreateJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateJobError {
fn description(&self) -> &str {
match *self {
CreateJobError::BadRequest(ref cause) => cause,
CreateJobError::Conflict(ref cause) => cause,
CreateJobError::Forbidden(ref cause) => cause,
CreateJobError::InternalServerError(ref cause) => cause,
CreateJobError::NotFound(ref cause) => cause,
CreateJobError::TooManyRequests(ref cause) => cause,
CreateJobError::Validation(ref cause) => cause,
CreateJobError::Credentials(ref err) => err.description(),
CreateJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateJobError::ParseError(ref cause) => cause,
CreateJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateJobTemplateError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateJobTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> CreateJobTemplateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateJobTemplateError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return CreateJobTemplateError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return CreateJobTemplateError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return CreateJobTemplateError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return CreateJobTemplateError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return CreateJobTemplateError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return CreateJobTemplateError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateJobTemplateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateJobTemplateError {
fn from(err: serde_json::error::Error) -> CreateJobTemplateError {
CreateJobTemplateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateJobTemplateError {
fn from(err: CredentialsError) -> CreateJobTemplateError {
CreateJobTemplateError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateJobTemplateError {
fn from(err: HttpDispatchError) -> CreateJobTemplateError {
CreateJobTemplateError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateJobTemplateError {
fn from(err: io::Error) -> CreateJobTemplateError {
CreateJobTemplateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateJobTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateJobTemplateError {
fn description(&self) -> &str {
match *self {
CreateJobTemplateError::BadRequest(ref cause) => cause,
CreateJobTemplateError::Conflict(ref cause) => cause,
CreateJobTemplateError::Forbidden(ref cause) => cause,
CreateJobTemplateError::InternalServerError(ref cause) => cause,
CreateJobTemplateError::NotFound(ref cause) => cause,
CreateJobTemplateError::TooManyRequests(ref cause) => cause,
CreateJobTemplateError::Validation(ref cause) => cause,
CreateJobTemplateError::Credentials(ref err) => err.description(),
CreateJobTemplateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateJobTemplateError::ParseError(ref cause) => cause,
CreateJobTemplateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreatePresetError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreatePresetError {
pub fn from_response(res: BufferedHttpResponse) -> CreatePresetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreatePresetError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return CreatePresetError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return CreatePresetError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return CreatePresetError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return CreatePresetError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return CreatePresetError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return CreatePresetError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreatePresetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreatePresetError {
fn from(err: serde_json::error::Error) -> CreatePresetError {
CreatePresetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreatePresetError {
fn from(err: CredentialsError) -> CreatePresetError {
CreatePresetError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreatePresetError {
fn from(err: HttpDispatchError) -> CreatePresetError {
CreatePresetError::HttpDispatch(err)
}
}
impl From<io::Error> for CreatePresetError {
fn from(err: io::Error) -> CreatePresetError {
CreatePresetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreatePresetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreatePresetError {
fn description(&self) -> &str {
match *self {
CreatePresetError::BadRequest(ref cause) => cause,
CreatePresetError::Conflict(ref cause) => cause,
CreatePresetError::Forbidden(ref cause) => cause,
CreatePresetError::InternalServerError(ref cause) => cause,
CreatePresetError::NotFound(ref cause) => cause,
CreatePresetError::TooManyRequests(ref cause) => cause,
CreatePresetError::Validation(ref cause) => cause,
CreatePresetError::Credentials(ref err) => err.description(),
CreatePresetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreatePresetError::ParseError(ref cause) => cause,
CreatePresetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateQueueError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateQueueError {
pub fn from_response(res: BufferedHttpResponse) -> CreateQueueError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateQueueError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return CreateQueueError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return CreateQueueError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return CreateQueueError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return CreateQueueError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return CreateQueueError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return CreateQueueError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateQueueError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateQueueError {
fn from(err: serde_json::error::Error) -> CreateQueueError {
CreateQueueError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateQueueError {
fn from(err: CredentialsError) -> CreateQueueError {
CreateQueueError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateQueueError {
fn from(err: HttpDispatchError) -> CreateQueueError {
CreateQueueError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateQueueError {
fn from(err: io::Error) -> CreateQueueError {
CreateQueueError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateQueueError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateQueueError {
fn description(&self) -> &str {
match *self {
CreateQueueError::BadRequest(ref cause) => cause,
CreateQueueError::Conflict(ref cause) => cause,
CreateQueueError::Forbidden(ref cause) => cause,
CreateQueueError::InternalServerError(ref cause) => cause,
CreateQueueError::NotFound(ref cause) => cause,
CreateQueueError::TooManyRequests(ref cause) => cause,
CreateQueueError::Validation(ref cause) => cause,
CreateQueueError::Credentials(ref err) => err.description(),
CreateQueueError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateQueueError::ParseError(ref cause) => cause,
CreateQueueError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteJobTemplateError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteJobTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteJobTemplateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteJobTemplateError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return DeleteJobTemplateError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return DeleteJobTemplateError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return DeleteJobTemplateError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return DeleteJobTemplateError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return DeleteJobTemplateError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return DeleteJobTemplateError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteJobTemplateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteJobTemplateError {
fn from(err: serde_json::error::Error) -> DeleteJobTemplateError {
DeleteJobTemplateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteJobTemplateError {
fn from(err: CredentialsError) -> DeleteJobTemplateError {
DeleteJobTemplateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteJobTemplateError {
fn from(err: HttpDispatchError) -> DeleteJobTemplateError {
DeleteJobTemplateError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteJobTemplateError {
fn from(err: io::Error) -> DeleteJobTemplateError {
DeleteJobTemplateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteJobTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteJobTemplateError {
fn description(&self) -> &str {
match *self {
DeleteJobTemplateError::BadRequest(ref cause) => cause,
DeleteJobTemplateError::Conflict(ref cause) => cause,
DeleteJobTemplateError::Forbidden(ref cause) => cause,
DeleteJobTemplateError::InternalServerError(ref cause) => cause,
DeleteJobTemplateError::NotFound(ref cause) => cause,
DeleteJobTemplateError::TooManyRequests(ref cause) => cause,
DeleteJobTemplateError::Validation(ref cause) => cause,
DeleteJobTemplateError::Credentials(ref err) => err.description(),
DeleteJobTemplateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteJobTemplateError::ParseError(ref cause) => cause,
DeleteJobTemplateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeletePresetError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeletePresetError {
pub fn from_response(res: BufferedHttpResponse) -> DeletePresetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeletePresetError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return DeletePresetError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return DeletePresetError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return DeletePresetError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return DeletePresetError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return DeletePresetError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return DeletePresetError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeletePresetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeletePresetError {
fn from(err: serde_json::error::Error) -> DeletePresetError {
DeletePresetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeletePresetError {
fn from(err: CredentialsError) -> DeletePresetError {
DeletePresetError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeletePresetError {
fn from(err: HttpDispatchError) -> DeletePresetError {
DeletePresetError::HttpDispatch(err)
}
}
impl From<io::Error> for DeletePresetError {
fn from(err: io::Error) -> DeletePresetError {
DeletePresetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeletePresetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeletePresetError {
fn description(&self) -> &str {
match *self {
DeletePresetError::BadRequest(ref cause) => cause,
DeletePresetError::Conflict(ref cause) => cause,
DeletePresetError::Forbidden(ref cause) => cause,
DeletePresetError::InternalServerError(ref cause) => cause,
DeletePresetError::NotFound(ref cause) => cause,
DeletePresetError::TooManyRequests(ref cause) => cause,
DeletePresetError::Validation(ref cause) => cause,
DeletePresetError::Credentials(ref err) => err.description(),
DeletePresetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeletePresetError::ParseError(ref cause) => cause,
DeletePresetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteQueueError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteQueueError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteQueueError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteQueueError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return DeleteQueueError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return DeleteQueueError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return DeleteQueueError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return DeleteQueueError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return DeleteQueueError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return DeleteQueueError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteQueueError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteQueueError {
fn from(err: serde_json::error::Error) -> DeleteQueueError {
DeleteQueueError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteQueueError {
fn from(err: CredentialsError) -> DeleteQueueError {
DeleteQueueError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteQueueError {
fn from(err: HttpDispatchError) -> DeleteQueueError {
DeleteQueueError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteQueueError {
fn from(err: io::Error) -> DeleteQueueError {
DeleteQueueError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteQueueError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteQueueError {
fn description(&self) -> &str {
match *self {
DeleteQueueError::BadRequest(ref cause) => cause,
DeleteQueueError::Conflict(ref cause) => cause,
DeleteQueueError::Forbidden(ref cause) => cause,
DeleteQueueError::InternalServerError(ref cause) => cause,
DeleteQueueError::NotFound(ref cause) => cause,
DeleteQueueError::TooManyRequests(ref cause) => cause,
DeleteQueueError::Validation(ref cause) => cause,
DeleteQueueError::Credentials(ref err) => err.description(),
DeleteQueueError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteQueueError::ParseError(ref cause) => cause,
DeleteQueueError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEndpointsError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEndpointsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DescribeEndpointsError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return DescribeEndpointsError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return DescribeEndpointsError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return DescribeEndpointsError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return DescribeEndpointsError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return DescribeEndpointsError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return DescribeEndpointsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeEndpointsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEndpointsError {
fn from(err: serde_json::error::Error) -> DescribeEndpointsError {
DescribeEndpointsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEndpointsError {
fn from(err: CredentialsError) -> DescribeEndpointsError {
DescribeEndpointsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEndpointsError {
fn from(err: HttpDispatchError) -> DescribeEndpointsError {
DescribeEndpointsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEndpointsError {
fn from(err: io::Error) -> DescribeEndpointsError {
DescribeEndpointsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEndpointsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEndpointsError {
fn description(&self) -> &str {
match *self {
DescribeEndpointsError::BadRequest(ref cause) => cause,
DescribeEndpointsError::Conflict(ref cause) => cause,
DescribeEndpointsError::Forbidden(ref cause) => cause,
DescribeEndpointsError::InternalServerError(ref cause) => cause,
DescribeEndpointsError::NotFound(ref cause) => cause,
DescribeEndpointsError::TooManyRequests(ref cause) => cause,
DescribeEndpointsError::Validation(ref cause) => cause,
DescribeEndpointsError::Credentials(ref err) => err.description(),
DescribeEndpointsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEndpointsError::ParseError(ref cause) => cause,
DescribeEndpointsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateCertificateError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateCertificateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DisassociateCertificateError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return DisassociateCertificateError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return DisassociateCertificateError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return DisassociateCertificateError::InternalServerError(String::from(
error_message,
));
}
"NotFoundException" => {
return DisassociateCertificateError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return DisassociateCertificateError::TooManyRequests(String::from(
error_message,
));
}
"ValidationException" => {
return DisassociateCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return DisassociateCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateCertificateError {
fn from(err: serde_json::error::Error) -> DisassociateCertificateError {
DisassociateCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateCertificateError {
fn from(err: CredentialsError) -> DisassociateCertificateError {
DisassociateCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateCertificateError {
fn from(err: HttpDispatchError) -> DisassociateCertificateError {
DisassociateCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateCertificateError {
fn from(err: io::Error) -> DisassociateCertificateError {
DisassociateCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateCertificateError {
fn description(&self) -> &str {
match *self {
DisassociateCertificateError::BadRequest(ref cause) => cause,
DisassociateCertificateError::Conflict(ref cause) => cause,
DisassociateCertificateError::Forbidden(ref cause) => cause,
DisassociateCertificateError::InternalServerError(ref cause) => cause,
DisassociateCertificateError::NotFound(ref cause) => cause,
DisassociateCertificateError::TooManyRequests(ref cause) => cause,
DisassociateCertificateError::Validation(ref cause) => cause,
DisassociateCertificateError::Credentials(ref err) => err.description(),
DisassociateCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateCertificateError::ParseError(ref cause) => cause,
DisassociateCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetJobError::BadRequest(String::from(error_message));
}
"ConflictException" => return GetJobError::Conflict(String::from(error_message)),
"ForbiddenException" => return GetJobError::Forbidden(String::from(error_message)),
"InternalServerErrorException" => {
return GetJobError::InternalServerError(String::from(error_message));
}
"NotFoundException" => return GetJobError::NotFound(String::from(error_message)),
"TooManyRequestsException" => {
return GetJobError::TooManyRequests(String::from(error_message));
}
"ValidationException" => return GetJobError::Validation(error_message.to_string()),
_ => {}
}
}
return GetJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobError {
fn from(err: serde_json::error::Error) -> GetJobError {
GetJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobError {
fn from(err: CredentialsError) -> GetJobError {
GetJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobError {
fn from(err: HttpDispatchError) -> GetJobError {
GetJobError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobError {
fn from(err: io::Error) -> GetJobError {
GetJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobError {
fn description(&self) -> &str {
match *self {
GetJobError::BadRequest(ref cause) => cause,
GetJobError::Conflict(ref cause) => cause,
GetJobError::Forbidden(ref cause) => cause,
GetJobError::InternalServerError(ref cause) => cause,
GetJobError::NotFound(ref cause) => cause,
GetJobError::TooManyRequests(ref cause) => cause,
GetJobError::Validation(ref cause) => cause,
GetJobError::Credentials(ref err) => err.description(),
GetJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobError::ParseError(ref cause) => cause,
GetJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobTemplateError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobTemplateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetJobTemplateError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return GetJobTemplateError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return GetJobTemplateError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return GetJobTemplateError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return GetJobTemplateError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return GetJobTemplateError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return GetJobTemplateError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetJobTemplateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobTemplateError {
fn from(err: serde_json::error::Error) -> GetJobTemplateError {
GetJobTemplateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobTemplateError {
fn from(err: CredentialsError) -> GetJobTemplateError {
GetJobTemplateError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobTemplateError {
fn from(err: HttpDispatchError) -> GetJobTemplateError {
GetJobTemplateError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobTemplateError {
fn from(err: io::Error) -> GetJobTemplateError {
GetJobTemplateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobTemplateError {
fn description(&self) -> &str {
match *self {
GetJobTemplateError::BadRequest(ref cause) => cause,
GetJobTemplateError::Conflict(ref cause) => cause,
GetJobTemplateError::Forbidden(ref cause) => cause,
GetJobTemplateError::InternalServerError(ref cause) => cause,
GetJobTemplateError::NotFound(ref cause) => cause,
GetJobTemplateError::TooManyRequests(ref cause) => cause,
GetJobTemplateError::Validation(ref cause) => cause,
GetJobTemplateError::Credentials(ref err) => err.description(),
GetJobTemplateError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobTemplateError::ParseError(ref cause) => cause,
GetJobTemplateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetPresetError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetPresetError {
pub fn from_response(res: BufferedHttpResponse) -> GetPresetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetPresetError::BadRequest(String::from(error_message));
}
"ConflictException" => return GetPresetError::Conflict(String::from(error_message)),
"ForbiddenException" => {
return GetPresetError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return GetPresetError::InternalServerError(String::from(error_message));
}
"NotFoundException" => return GetPresetError::NotFound(String::from(error_message)),
"TooManyRequestsException" => {
return GetPresetError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return GetPresetError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetPresetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetPresetError {
fn from(err: serde_json::error::Error) -> GetPresetError {
GetPresetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetPresetError {
fn from(err: CredentialsError) -> GetPresetError {
GetPresetError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetPresetError {
fn from(err: HttpDispatchError) -> GetPresetError {
GetPresetError::HttpDispatch(err)
}
}
impl From<io::Error> for GetPresetError {
fn from(err: io::Error) -> GetPresetError {
GetPresetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetPresetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetPresetError {
fn description(&self) -> &str {
match *self {
GetPresetError::BadRequest(ref cause) => cause,
GetPresetError::Conflict(ref cause) => cause,
GetPresetError::Forbidden(ref cause) => cause,
GetPresetError::InternalServerError(ref cause) => cause,
GetPresetError::NotFound(ref cause) => cause,
GetPresetError::TooManyRequests(ref cause) => cause,
GetPresetError::Validation(ref cause) => cause,
GetPresetError::Credentials(ref err) => err.description(),
GetPresetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetPresetError::ParseError(ref cause) => cause,
GetPresetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetQueueError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetQueueError {
pub fn from_response(res: BufferedHttpResponse) -> GetQueueError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetQueueError::BadRequest(String::from(error_message));
}
"ConflictException" => return GetQueueError::Conflict(String::from(error_message)),
"ForbiddenException" => {
return GetQueueError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return GetQueueError::InternalServerError(String::from(error_message));
}
"NotFoundException" => return GetQueueError::NotFound(String::from(error_message)),
"TooManyRequestsException" => {
return GetQueueError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return GetQueueError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetQueueError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetQueueError {
fn from(err: serde_json::error::Error) -> GetQueueError {
GetQueueError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetQueueError {
fn from(err: CredentialsError) -> GetQueueError {
GetQueueError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetQueueError {
fn from(err: HttpDispatchError) -> GetQueueError {
GetQueueError::HttpDispatch(err)
}
}
impl From<io::Error> for GetQueueError {
fn from(err: io::Error) -> GetQueueError {
GetQueueError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetQueueError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetQueueError {
fn description(&self) -> &str {
match *self {
GetQueueError::BadRequest(ref cause) => cause,
GetQueueError::Conflict(ref cause) => cause,
GetQueueError::Forbidden(ref cause) => cause,
GetQueueError::InternalServerError(ref cause) => cause,
GetQueueError::NotFound(ref cause) => cause,
GetQueueError::TooManyRequests(ref cause) => cause,
GetQueueError::Validation(ref cause) => cause,
GetQueueError::Credentials(ref err) => err.description(),
GetQueueError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetQueueError::ParseError(ref cause) => cause,
GetQueueError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListJobTemplatesError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListJobTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> ListJobTemplatesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListJobTemplatesError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return ListJobTemplatesError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return ListJobTemplatesError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return ListJobTemplatesError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return ListJobTemplatesError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return ListJobTemplatesError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return ListJobTemplatesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListJobTemplatesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListJobTemplatesError {
fn from(err: serde_json::error::Error) -> ListJobTemplatesError {
ListJobTemplatesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListJobTemplatesError {
fn from(err: CredentialsError) -> ListJobTemplatesError {
ListJobTemplatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListJobTemplatesError {
fn from(err: HttpDispatchError) -> ListJobTemplatesError {
ListJobTemplatesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListJobTemplatesError {
fn from(err: io::Error) -> ListJobTemplatesError {
ListJobTemplatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListJobTemplatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListJobTemplatesError {
fn description(&self) -> &str {
match *self {
ListJobTemplatesError::BadRequest(ref cause) => cause,
ListJobTemplatesError::Conflict(ref cause) => cause,
ListJobTemplatesError::Forbidden(ref cause) => cause,
ListJobTemplatesError::InternalServerError(ref cause) => cause,
ListJobTemplatesError::NotFound(ref cause) => cause,
ListJobTemplatesError::TooManyRequests(ref cause) => cause,
ListJobTemplatesError::Validation(ref cause) => cause,
ListJobTemplatesError::Credentials(ref err) => err.description(),
ListJobTemplatesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListJobTemplatesError::ParseError(ref cause) => cause,
ListJobTemplatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListJobsError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListJobsError {
pub fn from_response(res: BufferedHttpResponse) -> ListJobsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListJobsError::BadRequest(String::from(error_message));
}
"ConflictException" => return ListJobsError::Conflict(String::from(error_message)),
"ForbiddenException" => {
return ListJobsError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return ListJobsError::InternalServerError(String::from(error_message));
}
"NotFoundException" => return ListJobsError::NotFound(String::from(error_message)),
"TooManyRequestsException" => {
return ListJobsError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return ListJobsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListJobsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListJobsError {
fn from(err: serde_json::error::Error) -> ListJobsError {
ListJobsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListJobsError {
fn from(err: CredentialsError) -> ListJobsError {
ListJobsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListJobsError {
fn from(err: HttpDispatchError) -> ListJobsError {
ListJobsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListJobsError {
fn from(err: io::Error) -> ListJobsError {
ListJobsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListJobsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListJobsError {
fn description(&self) -> &str {
match *self {
ListJobsError::BadRequest(ref cause) => cause,
ListJobsError::Conflict(ref cause) => cause,
ListJobsError::Forbidden(ref cause) => cause,
ListJobsError::InternalServerError(ref cause) => cause,
ListJobsError::NotFound(ref cause) => cause,
ListJobsError::TooManyRequests(ref cause) => cause,
ListJobsError::Validation(ref cause) => cause,
ListJobsError::Credentials(ref err) => err.description(),
ListJobsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListJobsError::ParseError(ref cause) => cause,
ListJobsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListPresetsError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListPresetsError {
pub fn from_response(res: BufferedHttpResponse) -> ListPresetsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListPresetsError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return ListPresetsError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return ListPresetsError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return ListPresetsError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return ListPresetsError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return ListPresetsError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return ListPresetsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListPresetsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListPresetsError {
fn from(err: serde_json::error::Error) -> ListPresetsError {
ListPresetsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListPresetsError {
fn from(err: CredentialsError) -> ListPresetsError {
ListPresetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListPresetsError {
fn from(err: HttpDispatchError) -> ListPresetsError {
ListPresetsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListPresetsError {
fn from(err: io::Error) -> ListPresetsError {
ListPresetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListPresetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListPresetsError {
fn description(&self) -> &str {
match *self {
ListPresetsError::BadRequest(ref cause) => cause,
ListPresetsError::Conflict(ref cause) => cause,
ListPresetsError::Forbidden(ref cause) => cause,
ListPresetsError::InternalServerError(ref cause) => cause,
ListPresetsError::NotFound(ref cause) => cause,
ListPresetsError::TooManyRequests(ref cause) => cause,
ListPresetsError::Validation(ref cause) => cause,
ListPresetsError::Credentials(ref err) => err.description(),
ListPresetsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListPresetsError::ParseError(ref cause) => cause,
ListPresetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListQueuesError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListQueuesError {
pub fn from_response(res: BufferedHttpResponse) -> ListQueuesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListQueuesError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return ListQueuesError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return ListQueuesError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return ListQueuesError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return ListQueuesError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return ListQueuesError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return ListQueuesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListQueuesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListQueuesError {
fn from(err: serde_json::error::Error) -> ListQueuesError {
ListQueuesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListQueuesError {
fn from(err: CredentialsError) -> ListQueuesError {
ListQueuesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListQueuesError {
fn from(err: HttpDispatchError) -> ListQueuesError {
ListQueuesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListQueuesError {
fn from(err: io::Error) -> ListQueuesError {
ListQueuesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListQueuesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListQueuesError {
fn description(&self) -> &str {
match *self {
ListQueuesError::BadRequest(ref cause) => cause,
ListQueuesError::Conflict(ref cause) => cause,
ListQueuesError::Forbidden(ref cause) => cause,
ListQueuesError::InternalServerError(ref cause) => cause,
ListQueuesError::NotFound(ref cause) => cause,
ListQueuesError::TooManyRequests(ref cause) => cause,
ListQueuesError::Validation(ref cause) => cause,
ListQueuesError::Credentials(ref err) => err.description(),
ListQueuesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListQueuesError::ParseError(ref cause) => cause,
ListQueuesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListTagsForResourceError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return ListTagsForResourceError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return ListTagsForResourceError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return ListTagsForResourceError::InternalServerError(String::from(
error_message,
));
}
"NotFoundException" => {
return ListTagsForResourceError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return ListTagsForResourceError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return ListTagsForResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListTagsForResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsForResourceError {
fn from(err: serde_json::error::Error) -> ListTagsForResourceError {
ListTagsForResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => cause,
ListTagsForResourceError::Conflict(ref cause) => cause,
ListTagsForResourceError::Forbidden(ref cause) => cause,
ListTagsForResourceError::InternalServerError(ref cause) => cause,
ListTagsForResourceError::NotFound(ref cause) => cause,
ListTagsForResourceError::TooManyRequests(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> TagResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return TagResourceError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return TagResourceError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return TagResourceError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return TagResourceError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return TagResourceError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return TagResourceError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return TagResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return TagResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for TagResourceError {
fn from(err: serde_json::error::Error) -> TagResourceError {
TagResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for TagResourceError {
fn from(err: CredentialsError) -> TagResourceError {
TagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for TagResourceError {
fn from(err: HttpDispatchError) -> TagResourceError {
TagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for TagResourceError {
fn from(err: io::Error) -> TagResourceError {
TagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TagResourceError {
fn description(&self) -> &str {
match *self {
TagResourceError::BadRequest(ref cause) => cause,
TagResourceError::Conflict(ref cause) => cause,
TagResourceError::Forbidden(ref cause) => cause,
TagResourceError::InternalServerError(ref cause) => cause,
TagResourceError::NotFound(ref cause) => cause,
TagResourceError::TooManyRequests(ref cause) => cause,
TagResourceError::Validation(ref cause) => cause,
TagResourceError::Credentials(ref err) => err.description(),
TagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TagResourceError::ParseError(ref cause) => cause,
TagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> UntagResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UntagResourceError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return UntagResourceError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return UntagResourceError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return UntagResourceError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return UntagResourceError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return UntagResourceError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return UntagResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return UntagResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UntagResourceError {
fn from(err: serde_json::error::Error) -> UntagResourceError {
UntagResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UntagResourceError {
fn from(err: CredentialsError) -> UntagResourceError {
UntagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UntagResourceError {
fn from(err: HttpDispatchError) -> UntagResourceError {
UntagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for UntagResourceError {
fn from(err: io::Error) -> UntagResourceError {
UntagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UntagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UntagResourceError {
fn description(&self) -> &str {
match *self {
UntagResourceError::BadRequest(ref cause) => cause,
UntagResourceError::Conflict(ref cause) => cause,
UntagResourceError::Forbidden(ref cause) => cause,
UntagResourceError::InternalServerError(ref cause) => cause,
UntagResourceError::NotFound(ref cause) => cause,
UntagResourceError::TooManyRequests(ref cause) => cause,
UntagResourceError::Validation(ref cause) => cause,
UntagResourceError::Credentials(ref err) => err.description(),
UntagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UntagResourceError::ParseError(ref cause) => cause,
UntagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateJobTemplateError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateJobTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateJobTemplateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateJobTemplateError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return UpdateJobTemplateError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return UpdateJobTemplateError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return UpdateJobTemplateError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return UpdateJobTemplateError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return UpdateJobTemplateError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return UpdateJobTemplateError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateJobTemplateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateJobTemplateError {
fn from(err: serde_json::error::Error) -> UpdateJobTemplateError {
UpdateJobTemplateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateJobTemplateError {
fn from(err: CredentialsError) -> UpdateJobTemplateError {
UpdateJobTemplateError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateJobTemplateError {
fn from(err: HttpDispatchError) -> UpdateJobTemplateError {
UpdateJobTemplateError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateJobTemplateError {
fn from(err: io::Error) -> UpdateJobTemplateError {
UpdateJobTemplateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateJobTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateJobTemplateError {
fn description(&self) -> &str {
match *self {
UpdateJobTemplateError::BadRequest(ref cause) => cause,
UpdateJobTemplateError::Conflict(ref cause) => cause,
UpdateJobTemplateError::Forbidden(ref cause) => cause,
UpdateJobTemplateError::InternalServerError(ref cause) => cause,
UpdateJobTemplateError::NotFound(ref cause) => cause,
UpdateJobTemplateError::TooManyRequests(ref cause) => cause,
UpdateJobTemplateError::Validation(ref cause) => cause,
UpdateJobTemplateError::Credentials(ref err) => err.description(),
UpdateJobTemplateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateJobTemplateError::ParseError(ref cause) => cause,
UpdateJobTemplateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdatePresetError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdatePresetError {
pub fn from_response(res: BufferedHttpResponse) -> UpdatePresetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdatePresetError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return UpdatePresetError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return UpdatePresetError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return UpdatePresetError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return UpdatePresetError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return UpdatePresetError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return UpdatePresetError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdatePresetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdatePresetError {
fn from(err: serde_json::error::Error) -> UpdatePresetError {
UpdatePresetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdatePresetError {
fn from(err: CredentialsError) -> UpdatePresetError {
UpdatePresetError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdatePresetError {
fn from(err: HttpDispatchError) -> UpdatePresetError {
UpdatePresetError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdatePresetError {
fn from(err: io::Error) -> UpdatePresetError {
UpdatePresetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdatePresetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdatePresetError {
fn description(&self) -> &str {
match *self {
UpdatePresetError::BadRequest(ref cause) => cause,
UpdatePresetError::Conflict(ref cause) => cause,
UpdatePresetError::Forbidden(ref cause) => cause,
UpdatePresetError::InternalServerError(ref cause) => cause,
UpdatePresetError::NotFound(ref cause) => cause,
UpdatePresetError::TooManyRequests(ref cause) => cause,
UpdatePresetError::Validation(ref cause) => cause,
UpdatePresetError::Credentials(ref err) => err.description(),
UpdatePresetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdatePresetError::ParseError(ref cause) => cause,
UpdatePresetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateQueueError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateQueueError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateQueueError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateQueueError::BadRequest(String::from(error_message));
}
"ConflictException" => {
return UpdateQueueError::Conflict(String::from(error_message));
}
"ForbiddenException" => {
return UpdateQueueError::Forbidden(String::from(error_message));
}
"InternalServerErrorException" => {
return UpdateQueueError::InternalServerError(String::from(error_message));
}
"NotFoundException" => {
return UpdateQueueError::NotFound(String::from(error_message));
}
"TooManyRequestsException" => {
return UpdateQueueError::TooManyRequests(String::from(error_message));
}
"ValidationException" => {
return UpdateQueueError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateQueueError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateQueueError {
fn from(err: serde_json::error::Error) -> UpdateQueueError {
UpdateQueueError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateQueueError {
fn from(err: CredentialsError) -> UpdateQueueError {
UpdateQueueError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateQueueError {
fn from(err: HttpDispatchError) -> UpdateQueueError {
UpdateQueueError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateQueueError {
fn from(err: io::Error) -> UpdateQueueError {
UpdateQueueError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateQueueError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateQueueError {
fn description(&self) -> &str {
match *self {
UpdateQueueError::BadRequest(ref cause) => cause,
UpdateQueueError::Conflict(ref cause) => cause,
UpdateQueueError::Forbidden(ref cause) => cause,
UpdateQueueError::InternalServerError(ref cause) => cause,
UpdateQueueError::NotFound(ref cause) => cause,
UpdateQueueError::TooManyRequests(ref cause) => cause,
UpdateQueueError::Validation(ref cause) => cause,
UpdateQueueError::Credentials(ref err) => err.description(),
UpdateQueueError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateQueueError::ParseError(ref cause) => cause,
UpdateQueueError::Unknown(_) => "unknown error",
}
}
}
pub trait MediaConvert {
fn associate_certificate(
&self,
input: AssociateCertificateRequest,
) -> RusotoFuture<AssociateCertificateResponse, AssociateCertificateError>;
fn cancel_job(
&self,
input: CancelJobRequest,
) -> RusotoFuture<CancelJobResponse, CancelJobError>;
fn create_job(
&self,
input: CreateJobRequest,
) -> RusotoFuture<CreateJobResponse, CreateJobError>;
fn create_job_template(
&self,
input: CreateJobTemplateRequest,
) -> RusotoFuture<CreateJobTemplateResponse, CreateJobTemplateError>;
fn create_preset(
&self,
input: CreatePresetRequest,
) -> RusotoFuture<CreatePresetResponse, CreatePresetError>;
fn create_queue(
&self,
input: CreateQueueRequest,
) -> RusotoFuture<CreateQueueResponse, CreateQueueError>;
fn delete_job_template(
&self,
input: DeleteJobTemplateRequest,
) -> RusotoFuture<DeleteJobTemplateResponse, DeleteJobTemplateError>;
fn delete_preset(
&self,
input: DeletePresetRequest,
) -> RusotoFuture<DeletePresetResponse, DeletePresetError>;
fn delete_queue(
&self,
input: DeleteQueueRequest,
) -> RusotoFuture<DeleteQueueResponse, DeleteQueueError>;
fn describe_endpoints(
&self,
input: DescribeEndpointsRequest,
) -> RusotoFuture<DescribeEndpointsResponse, DescribeEndpointsError>;
fn disassociate_certificate(
&self,
input: DisassociateCertificateRequest,
) -> RusotoFuture<DisassociateCertificateResponse, DisassociateCertificateError>;
fn get_job(&self, input: GetJobRequest) -> RusotoFuture<GetJobResponse, GetJobError>;
fn get_job_template(
&self,
input: GetJobTemplateRequest,
) -> RusotoFuture<GetJobTemplateResponse, GetJobTemplateError>;
fn get_preset(
&self,
input: GetPresetRequest,
) -> RusotoFuture<GetPresetResponse, GetPresetError>;
fn get_queue(&self, input: GetQueueRequest) -> RusotoFuture<GetQueueResponse, GetQueueError>;
fn list_job_templates(
&self,
input: ListJobTemplatesRequest,
) -> RusotoFuture<ListJobTemplatesResponse, ListJobTemplatesError>;
fn list_jobs(&self, input: ListJobsRequest) -> RusotoFuture<ListJobsResponse, ListJobsError>;
fn list_presets(
&self,
input: ListPresetsRequest,
) -> RusotoFuture<ListPresetsResponse, ListPresetsError>;
fn list_queues(
&self,
input: ListQueuesRequest,
) -> RusotoFuture<ListQueuesResponse, ListQueuesError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError>;
fn tag_resource(
&self,
input: TagResourceRequest,
) -> RusotoFuture<TagResourceResponse, TagResourceError>;
fn untag_resource(
&self,
input: UntagResourceRequest,
) -> RusotoFuture<UntagResourceResponse, UntagResourceError>;
fn update_job_template(
&self,
input: UpdateJobTemplateRequest,
) -> RusotoFuture<UpdateJobTemplateResponse, UpdateJobTemplateError>;
fn update_preset(
&self,
input: UpdatePresetRequest,
) -> RusotoFuture<UpdatePresetResponse, UpdatePresetError>;
fn update_queue(
&self,
input: UpdateQueueRequest,
) -> RusotoFuture<UpdateQueueResponse, UpdateQueueError>;
}
#[derive(Clone)]
pub struct MediaConvertClient {
client: Client,
region: region::Region,
}
impl MediaConvertClient {
pub fn new(region: region::Region) -> MediaConvertClient {
MediaConvertClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MediaConvertClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
MediaConvertClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl MediaConvert for MediaConvertClient {
fn associate_certificate(
&self,
input: AssociateCertificateRequest,
) -> RusotoFuture<AssociateCertificateResponse, AssociateCertificateError> {
let request_uri = "/2017-08-29/certificates";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 201 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<AssociateCertificateResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(AssociateCertificateError::from_response(response))
}),
)
}
})
}
fn cancel_job(
&self,
input: CancelJobRequest,
) -> RusotoFuture<CancelJobResponse, CancelJobError> {
let request_uri = format!("/2017-08-29/jobs/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 202 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CancelJobResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CancelJobError::from_response(response))),
)
}
})
}
fn create_job(
&self,
input: CreateJobRequest,
) -> RusotoFuture<CreateJobResponse, CreateJobError> {
let request_uri = "/2017-08-29/jobs";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 201 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CreateJobResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateJobError::from_response(response))),
)
}
})
}
fn create_job_template(
&self,
input: CreateJobTemplateRequest,
) -> RusotoFuture<CreateJobTemplateResponse, CreateJobTemplateError> {
let request_uri = "/2017-08-29/jobTemplates";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 201 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateJobTemplateResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateJobTemplateError::from_response(response))),
)
}
})
}
fn create_preset(
&self,
input: CreatePresetRequest,
) -> RusotoFuture<CreatePresetResponse, CreatePresetError> {
let request_uri = "/2017-08-29/presets";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 201 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CreatePresetResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreatePresetError::from_response(response))),
)
}
})
}
fn create_queue(
&self,
input: CreateQueueRequest,
) -> RusotoFuture<CreateQueueResponse, CreateQueueError> {
let request_uri = "/2017-08-29/queues";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 201 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CreateQueueResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateQueueError::from_response(response))),
)
}
})
}
fn delete_job_template(
&self,
input: DeleteJobTemplateRequest,
) -> RusotoFuture<DeleteJobTemplateResponse, DeleteJobTemplateError> {
let request_uri = format!("/2017-08-29/jobTemplates/{name}", name = input.name);
let mut request = SignedRequest::new("DELETE", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 202 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteJobTemplateResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteJobTemplateError::from_response(response))),
)
}
})
}
fn delete_preset(
&self,
input: DeletePresetRequest,
) -> RusotoFuture<DeletePresetResponse, DeletePresetError> {
let request_uri = format!("/2017-08-29/presets/{name}", name = input.name);
let mut request = SignedRequest::new("DELETE", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 202 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<DeletePresetResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeletePresetError::from_response(response))),
)
}
})
}
fn delete_queue(
&self,
input: DeleteQueueRequest,
) -> RusotoFuture<DeleteQueueResponse, DeleteQueueError> {
let request_uri = format!("/2017-08-29/queues/{name}", name = input.name);
let mut request = SignedRequest::new("DELETE", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 202 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<DeleteQueueResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteQueueError::from_response(response))),
)
}
})
}
fn describe_endpoints(
&self,
input: DescribeEndpointsRequest,
) -> RusotoFuture<DescribeEndpointsResponse, DescribeEndpointsError> {
let request_uri = "/2017-08-29/endpoints";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DescribeEndpointsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeEndpointsError::from_response(response))),
)
}
})
}
fn disassociate_certificate(
&self,
input: DisassociateCertificateRequest,
) -> RusotoFuture<DisassociateCertificateResponse, DisassociateCertificateError> {
let request_uri = "/2017-08-29/certificates/{arn}";
let mut request = SignedRequest::new("DELETE", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 202 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DisassociateCertificateResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateCertificateError::from_response(response))
}))
}
})
}
fn get_job(&self, input: GetJobRequest) -> RusotoFuture<GetJobResponse, GetJobError> {
let request_uri = format!("/2017-08-29/jobs/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetJobResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobError::from_response(response))),
)
}
})
}
fn get_job_template(
&self,
input: GetJobTemplateRequest,
) -> RusotoFuture<GetJobTemplateResponse, GetJobTemplateError> {
let request_uri = format!("/2017-08-29/jobTemplates/{name}", name = input.name);
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetJobTemplateResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobTemplateError::from_response(response))),
)
}
})
}
fn get_preset(
&self,
input: GetPresetRequest,
) -> RusotoFuture<GetPresetResponse, GetPresetError> {
let request_uri = format!("/2017-08-29/presets/{name}", name = input.name);
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetPresetResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetPresetError::from_response(response))),
)
}
})
}
fn get_queue(&self, input: GetQueueRequest) -> RusotoFuture<GetQueueResponse, GetQueueError> {
let request_uri = format!("/2017-08-29/queues/{name}", name = input.name);
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetQueueResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetQueueError::from_response(response))),
)
}
})
}
fn list_job_templates(
&self,
input: ListJobTemplatesRequest,
) -> RusotoFuture<ListJobTemplatesResponse, ListJobTemplatesError> {
let request_uri = "/2017-08-29/jobTemplates";
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.category {
params.put("category", x);
}
if let Some(ref x) = input.list_by {
params.put("listBy", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.order {
params.put("order", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListJobTemplatesResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListJobTemplatesError::from_response(response))),
)
}
})
}
fn list_jobs(&self, input: ListJobsRequest) -> RusotoFuture<ListJobsResponse, ListJobsError> {
let request_uri = "/2017-08-29/jobs";
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.order {
params.put("order", x);
}
if let Some(ref x) = input.queue {
params.put("queue", x);
}
if let Some(ref x) = input.status {
params.put("status", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListJobsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListJobsError::from_response(response))),
)
}
})
}
fn list_presets(
&self,
input: ListPresetsRequest,
) -> RusotoFuture<ListPresetsResponse, ListPresetsError> {
let request_uri = "/2017-08-29/presets";
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.category {
params.put("category", x);
}
if let Some(ref x) = input.list_by {
params.put("listBy", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.order {
params.put("order", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListPresetsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListPresetsError::from_response(response))),
)
}
})
}
fn list_queues(
&self,
input: ListQueuesRequest,
) -> RusotoFuture<ListQueuesResponse, ListQueuesError> {
let request_uri = "/2017-08-29/queues";
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.list_by {
params.put("listBy", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.order {
params.put("order", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListQueuesResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListQueuesError::from_response(response))),
)
}
})
}
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError> {
let request_uri = format!("/2017-08-29/tags/{arn}", arn = input.arn);
let mut request = SignedRequest::new("GET", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListTagsForResourceResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourceError::from_response(response))
}),
)
}
})
}
fn tag_resource(
&self,
input: TagResourceRequest,
) -> RusotoFuture<TagResourceResponse, TagResourceError> {
let request_uri = "/2017-08-29/tags";
let mut request = SignedRequest::new("POST", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<TagResourceResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TagResourceError::from_response(response))),
)
}
})
}
fn untag_resource(
&self,
input: UntagResourceRequest,
) -> RusotoFuture<UntagResourceResponse, UntagResourceError> {
let request_uri = format!("/2017-08-29/tags/{arn}", arn = input.arn);
let mut request = SignedRequest::new("PUT", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<UntagResourceResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UntagResourceError::from_response(response))),
)
}
})
}
fn update_job_template(
&self,
input: UpdateJobTemplateRequest,
) -> RusotoFuture<UpdateJobTemplateResponse, UpdateJobTemplateError> {
let request_uri = format!("/2017-08-29/jobTemplates/{name}", name = input.name);
let mut request = SignedRequest::new("PUT", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateJobTemplateResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateJobTemplateError::from_response(response))),
)
}
})
}
fn update_preset(
&self,
input: UpdatePresetRequest,
) -> RusotoFuture<UpdatePresetResponse, UpdatePresetError> {
let request_uri = format!("/2017-08-29/presets/{name}", name = input.name);
let mut request = SignedRequest::new("PUT", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<UpdatePresetResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdatePresetError::from_response(response))),
)
}
})
}
fn update_queue(
&self,
input: UpdateQueueRequest,
) -> RusotoFuture<UpdateQueueResponse, UpdateQueueError> {
let request_uri = format!("/2017-08-29/queues/{name}", name = input.name);
let mut request = SignedRequest::new("PUT", "mediaconvert", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<UpdateQueueResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateQueueError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}