use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssetShallow {
#[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<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "SourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
#[serde(rename = "SourceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_role_arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Authorization {
#[serde(rename = "CdnIdentifierSecret")]
pub cdn_identifier_secret: String,
#[serde(rename = "SecretsRoleArn")]
pub secrets_role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CmafEncryption {
#[serde(rename = "SpekeKeyProvider")]
pub speke_key_provider: SpekeKeyProvider,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CmafPackage {
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<CmafEncryption>,
#[serde(rename = "HlsManifests")]
pub hls_manifests: Vec<HlsManifest>,
#[serde(rename = "SegmentDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_duration_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAssetRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "PackagingGroupId")]
pub packaging_group_id: String,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "SourceArn")]
pub source_arn: String,
#[serde(rename = "SourceRoleArn")]
pub source_role_arn: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAssetResponse {
#[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<String>,
#[serde(rename = "EgressEndpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub egress_endpoints: Option<Vec<EgressEndpoint>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "SourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
#[serde(rename = "SourceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_role_arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePackagingConfigurationRequest {
#[serde(rename = "CmafPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cmaf_package: Option<CmafPackage>,
#[serde(rename = "DashPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_package: Option<DashPackage>,
#[serde(rename = "HlsPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_package: Option<HlsPackage>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "MssPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mss_package: Option<MssPackage>,
#[serde(rename = "PackagingGroupId")]
pub packaging_group_id: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePackagingConfigurationResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CmafPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cmaf_package: Option<CmafPackage>,
#[serde(rename = "DashPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_package: Option<DashPackage>,
#[serde(rename = "HlsPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_package: Option<HlsPackage>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "MssPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mss_package: Option<MssPackage>,
#[serde(rename = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePackagingGroupRequest {
#[serde(rename = "Authorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePackagingGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Authorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DashEncryption {
#[serde(rename = "SpekeKeyProvider")]
pub speke_key_provider: SpekeKeyProvider,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DashManifest {
#[serde(rename = "ManifestLayout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_layout: Option<String>,
#[serde(rename = "ManifestName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_name: Option<String>,
#[serde(rename = "MinBufferTimeSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_buffer_time_seconds: Option<i64>,
#[serde(rename = "Profile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub profile: Option<String>,
#[serde(rename = "StreamSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_selection: Option<StreamSelection>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DashPackage {
#[serde(rename = "DashManifests")]
pub dash_manifests: Vec<DashManifest>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<DashEncryption>,
#[serde(rename = "PeriodTriggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub period_triggers: Option<Vec<String>>,
#[serde(rename = "SegmentDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_duration_seconds: Option<i64>,
#[serde(rename = "SegmentTemplateFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_template_format: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAssetRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAssetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePackagingConfigurationRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePackagingConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePackagingGroupRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePackagingGroupResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAssetRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAssetResponse {
#[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<String>,
#[serde(rename = "EgressEndpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub egress_endpoints: Option<Vec<EgressEndpoint>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "SourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
#[serde(rename = "SourceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_role_arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePackagingConfigurationRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePackagingConfigurationResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CmafPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cmaf_package: Option<CmafPackage>,
#[serde(rename = "DashPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_package: Option<DashPackage>,
#[serde(rename = "HlsPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_package: Option<HlsPackage>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "MssPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mss_package: Option<MssPackage>,
#[serde(rename = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePackagingGroupRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePackagingGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Authorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EgressEndpoint {
#[serde(rename = "PackagingConfigurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_configuration_id: Option<String>,
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HlsEncryption {
#[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 = "SpekeKeyProvider")]
pub speke_key_provider: SpekeKeyProvider,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HlsManifest {
#[serde(rename = "AdMarkers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_markers: Option<String>,
#[serde(rename = "IncludeIframeOnlyStream")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_iframe_only_stream: Option<bool>,
#[serde(rename = "ManifestName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_name: Option<String>,
#[serde(rename = "ProgramDateTimeIntervalSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub program_date_time_interval_seconds: Option<i64>,
#[serde(rename = "RepeatExtXKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repeat_ext_x_key: Option<bool>,
#[serde(rename = "StreamSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_selection: Option<StreamSelection>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HlsPackage {
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<HlsEncryption>,
#[serde(rename = "HlsManifests")]
pub hls_manifests: Vec<HlsManifest>,
#[serde(rename = "SegmentDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_duration_seconds: Option<i64>,
#[serde(rename = "UseAudioRenditionGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_audio_rendition_group: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAssetsRequest {
#[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 = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAssetsResponse {
#[serde(rename = "Assets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assets: Option<Vec<AssetShallow>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPackagingConfigurationsRequest {
#[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 = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPackagingConfigurationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PackagingConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_configurations: Option<Vec<PackagingConfiguration>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPackagingGroupsRequest {
#[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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPackagingGroupsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PackagingGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_groups: Option<Vec<PackagingGroup>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MssEncryption {
#[serde(rename = "SpekeKeyProvider")]
pub speke_key_provider: SpekeKeyProvider,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MssManifest {
#[serde(rename = "ManifestName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_name: Option<String>,
#[serde(rename = "StreamSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_selection: Option<StreamSelection>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MssPackage {
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<MssEncryption>,
#[serde(rename = "MssManifests")]
pub mss_manifests: Vec<MssManifest>,
#[serde(rename = "SegmentDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment_duration_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PackagingConfiguration {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CmafPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cmaf_package: Option<CmafPackage>,
#[serde(rename = "DashPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_package: Option<DashPackage>,
#[serde(rename = "HlsPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_package: Option<HlsPackage>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "MssPackage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mss_package: Option<MssPackage>,
#[serde(rename = "PackagingGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packaging_group_id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PackagingGroup {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Authorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SpekeKeyProvider {
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "SystemIds")]
pub system_ids: Vec<String>,
#[serde(rename = "Url")]
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct StreamSelection {
#[serde(rename = "MaxVideoBitsPerSecond")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_video_bits_per_second: Option<i64>,
#[serde(rename = "MinVideoBitsPerSecond")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_video_bits_per_second: Option<i64>,
#[serde(rename = "StreamOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_order: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePackagingGroupRequest {
#[serde(rename = "Authorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePackagingGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Authorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Debug, PartialEq)]
pub enum CreateAssetError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl CreateAssetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAssetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(CreateAssetError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateAssetError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateAssetError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateAssetError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateAssetError::TooManyRequests(err.msg))
}
"UnprocessableEntityException" => {
return RusotoError::Service(CreateAssetError::UnprocessableEntity(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAssetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAssetError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateAssetError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateAssetError::NotFound(ref cause) => write!(f, "{}", cause),
CreateAssetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateAssetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
CreateAssetError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAssetError {}
#[derive(Debug, PartialEq)]
pub enum CreatePackagingConfigurationError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl CreatePackagingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreatePackagingConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(CreatePackagingConfigurationError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreatePackagingConfigurationError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(CreatePackagingConfigurationError::NotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
CreatePackagingConfigurationError::ServiceUnavailable(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
CreatePackagingConfigurationError::TooManyRequests(err.msg),
)
}
"UnprocessableEntityException" => {
return RusotoError::Service(
CreatePackagingConfigurationError::UnprocessableEntity(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePackagingConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePackagingConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
CreatePackagingConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
CreatePackagingConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
CreatePackagingConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
CreatePackagingConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
CreatePackagingConfigurationError::UnprocessableEntity(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreatePackagingConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum CreatePackagingGroupError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl CreatePackagingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePackagingGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(CreatePackagingGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreatePackagingGroupError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreatePackagingGroupError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreatePackagingGroupError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreatePackagingGroupError::TooManyRequests(
err.msg,
))
}
"UnprocessableEntityException" => {
return RusotoError::Service(CreatePackagingGroupError::UnprocessableEntity(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePackagingGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePackagingGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
CreatePackagingGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreatePackagingGroupError::NotFound(ref cause) => write!(f, "{}", cause),
CreatePackagingGroupError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreatePackagingGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
CreatePackagingGroupError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePackagingGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAssetError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl DeleteAssetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAssetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(DeleteAssetError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteAssetError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteAssetError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteAssetError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteAssetError::TooManyRequests(err.msg))
}
"UnprocessableEntityException" => {
return RusotoError::Service(DeleteAssetError::UnprocessableEntity(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAssetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAssetError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteAssetError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteAssetError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteAssetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteAssetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeleteAssetError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAssetError {}
#[derive(Debug, PartialEq)]
pub enum DeletePackagingConfigurationError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl DeletePackagingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeletePackagingConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(DeletePackagingConfigurationError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DeletePackagingConfigurationError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DeletePackagingConfigurationError::NotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DeletePackagingConfigurationError::ServiceUnavailable(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DeletePackagingConfigurationError::TooManyRequests(err.msg),
)
}
"UnprocessableEntityException" => {
return RusotoError::Service(
DeletePackagingConfigurationError::UnprocessableEntity(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePackagingConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePackagingConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
DeletePackagingConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DeletePackagingConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
DeletePackagingConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DeletePackagingConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeletePackagingConfigurationError::UnprocessableEntity(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeletePackagingConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeletePackagingGroupError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl DeletePackagingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePackagingGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(DeletePackagingGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeletePackagingGroupError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeletePackagingGroupError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeletePackagingGroupError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeletePackagingGroupError::TooManyRequests(
err.msg,
))
}
"UnprocessableEntityException" => {
return RusotoError::Service(DeletePackagingGroupError::UnprocessableEntity(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePackagingGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePackagingGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
DeletePackagingGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeletePackagingGroupError::NotFound(ref cause) => write!(f, "{}", cause),
DeletePackagingGroupError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeletePackagingGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeletePackagingGroupError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePackagingGroupError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAssetError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl DescribeAssetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAssetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(DescribeAssetError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DescribeAssetError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DescribeAssetError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeAssetError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeAssetError::TooManyRequests(err.msg))
}
"UnprocessableEntityException" => {
return RusotoError::Service(DescribeAssetError::UnprocessableEntity(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAssetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAssetError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribeAssetError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeAssetError::NotFound(ref cause) => write!(f, "{}", cause),
DescribeAssetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeAssetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribeAssetError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAssetError {}
#[derive(Debug, PartialEq)]
pub enum DescribePackagingConfigurationError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl DescribePackagingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribePackagingConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(DescribePackagingConfigurationError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DescribePackagingConfigurationError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DescribePackagingConfigurationError::NotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DescribePackagingConfigurationError::ServiceUnavailable(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribePackagingConfigurationError::TooManyRequests(err.msg),
)
}
"UnprocessableEntityException" => {
return RusotoError::Service(
DescribePackagingConfigurationError::UnprocessableEntity(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePackagingConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePackagingConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribePackagingConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribePackagingConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
DescribePackagingConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DescribePackagingConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DescribePackagingConfigurationError::UnprocessableEntity(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribePackagingConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribePackagingGroupError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl DescribePackagingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePackagingGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(DescribePackagingGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DescribePackagingGroupError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DescribePackagingGroupError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribePackagingGroupError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribePackagingGroupError::TooManyRequests(
err.msg,
))
}
"UnprocessableEntityException" => {
return RusotoError::Service(DescribePackagingGroupError::UnprocessableEntity(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePackagingGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePackagingGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribePackagingGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribePackagingGroupError::NotFound(ref cause) => write!(f, "{}", cause),
DescribePackagingGroupError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribePackagingGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribePackagingGroupError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribePackagingGroupError {}
#[derive(Debug, PartialEq)]
pub enum ListAssetsError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl ListAssetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAssetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(ListAssetsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListAssetsError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListAssetsError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListAssetsError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListAssetsError::TooManyRequests(err.msg))
}
"UnprocessableEntityException" => {
return RusotoError::Service(ListAssetsError::UnprocessableEntity(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAssetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAssetsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListAssetsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListAssetsError::NotFound(ref cause) => write!(f, "{}", cause),
ListAssetsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListAssetsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListAssetsError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAssetsError {}
#[derive(Debug, PartialEq)]
pub enum ListPackagingConfigurationsError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl ListPackagingConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListPackagingConfigurationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(ListPackagingConfigurationsError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
ListPackagingConfigurationsError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(ListPackagingConfigurationsError::NotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListPackagingConfigurationsError::ServiceUnavailable(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(ListPackagingConfigurationsError::TooManyRequests(
err.msg,
))
}
"UnprocessableEntityException" => {
return RusotoError::Service(
ListPackagingConfigurationsError::UnprocessableEntity(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPackagingConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPackagingConfigurationsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListPackagingConfigurationsError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
ListPackagingConfigurationsError::NotFound(ref cause) => write!(f, "{}", cause),
ListPackagingConfigurationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
ListPackagingConfigurationsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListPackagingConfigurationsError::UnprocessableEntity(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListPackagingConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum ListPackagingGroupsError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl ListPackagingGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPackagingGroupsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(ListPackagingGroupsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListPackagingGroupsError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListPackagingGroupsError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListPackagingGroupsError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListPackagingGroupsError::TooManyRequests(err.msg))
}
"UnprocessableEntityException" => {
return RusotoError::Service(ListPackagingGroupsError::UnprocessableEntity(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPackagingGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPackagingGroupsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListPackagingGroupsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListPackagingGroupsError::NotFound(ref cause) => write!(f, "{}", cause),
ListPackagingGroupsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListPackagingGroupsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListPackagingGroupsError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPackagingGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePackagingGroupError {
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
UnprocessableEntity(String),
}
impl UpdatePackagingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePackagingGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ForbiddenException" => {
return RusotoError::Service(UpdatePackagingGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdatePackagingGroupError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdatePackagingGroupError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdatePackagingGroupError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdatePackagingGroupError::TooManyRequests(
err.msg,
))
}
"UnprocessableEntityException" => {
return RusotoError::Service(UpdatePackagingGroupError::UnprocessableEntity(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePackagingGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePackagingGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdatePackagingGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdatePackagingGroupError::NotFound(ref cause) => write!(f, "{}", cause),
UpdatePackagingGroupError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdatePackagingGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdatePackagingGroupError::UnprocessableEntity(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdatePackagingGroupError {}
#[async_trait]
pub trait MediaPackageVod {
async fn create_asset(
&self,
input: CreateAssetRequest,
) -> Result<CreateAssetResponse, RusotoError<CreateAssetError>>;
async fn create_packaging_configuration(
&self,
input: CreatePackagingConfigurationRequest,
) -> Result<CreatePackagingConfigurationResponse, RusotoError<CreatePackagingConfigurationError>>;
async fn create_packaging_group(
&self,
input: CreatePackagingGroupRequest,
) -> Result<CreatePackagingGroupResponse, RusotoError<CreatePackagingGroupError>>;
async fn delete_asset(
&self,
input: DeleteAssetRequest,
) -> Result<DeleteAssetResponse, RusotoError<DeleteAssetError>>;
async fn delete_packaging_configuration(
&self,
input: DeletePackagingConfigurationRequest,
) -> Result<DeletePackagingConfigurationResponse, RusotoError<DeletePackagingConfigurationError>>;
async fn delete_packaging_group(
&self,
input: DeletePackagingGroupRequest,
) -> Result<DeletePackagingGroupResponse, RusotoError<DeletePackagingGroupError>>;
async fn describe_asset(
&self,
input: DescribeAssetRequest,
) -> Result<DescribeAssetResponse, RusotoError<DescribeAssetError>>;
async fn describe_packaging_configuration(
&self,
input: DescribePackagingConfigurationRequest,
) -> Result<
DescribePackagingConfigurationResponse,
RusotoError<DescribePackagingConfigurationError>,
>;
async fn describe_packaging_group(
&self,
input: DescribePackagingGroupRequest,
) -> Result<DescribePackagingGroupResponse, RusotoError<DescribePackagingGroupError>>;
async fn list_assets(
&self,
input: ListAssetsRequest,
) -> Result<ListAssetsResponse, RusotoError<ListAssetsError>>;
async fn list_packaging_configurations(
&self,
input: ListPackagingConfigurationsRequest,
) -> Result<ListPackagingConfigurationsResponse, RusotoError<ListPackagingConfigurationsError>>;
async fn list_packaging_groups(
&self,
input: ListPackagingGroupsRequest,
) -> Result<ListPackagingGroupsResponse, RusotoError<ListPackagingGroupsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_packaging_group(
&self,
input: UpdatePackagingGroupRequest,
) -> Result<UpdatePackagingGroupResponse, RusotoError<UpdatePackagingGroupError>>;
}
#[derive(Clone)]
pub struct MediaPackageVodClient {
client: Client,
region: region::Region,
}
impl MediaPackageVodClient {
pub fn new(region: region::Region) -> MediaPackageVodClient {
MediaPackageVodClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MediaPackageVodClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
MediaPackageVodClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> MediaPackageVodClient {
MediaPackageVodClient { client, region }
}
}
#[async_trait]
impl MediaPackageVod for MediaPackageVodClient {
#[allow(unused_mut)]
async fn create_asset(
&self,
input: CreateAssetRequest,
) -> Result<CreateAssetResponse, RusotoError<CreateAssetError>> {
let request_uri = "/assets";
let mut request =
SignedRequest::new("POST", "mediapackage-vod", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateAssetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateAssetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_packaging_configuration(
&self,
input: CreatePackagingConfigurationRequest,
) -> Result<CreatePackagingConfigurationResponse, RusotoError<CreatePackagingConfigurationError>>
{
let request_uri = "/packaging_configurations";
let mut request =
SignedRequest::new("POST", "mediapackage-vod", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePackagingConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreatePackagingConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_packaging_group(
&self,
input: CreatePackagingGroupRequest,
) -> Result<CreatePackagingGroupResponse, RusotoError<CreatePackagingGroupError>> {
let request_uri = "/packaging_groups";
let mut request =
SignedRequest::new("POST", "mediapackage-vod", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePackagingGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreatePackagingGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_asset(
&self,
input: DeleteAssetRequest,
) -> Result<DeleteAssetResponse, RusotoError<DeleteAssetError>> {
let request_uri = format!("/assets/{id}", id = input.id);
let mut request =
SignedRequest::new("DELETE", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteAssetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteAssetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_packaging_configuration(
&self,
input: DeletePackagingConfigurationRequest,
) -> Result<DeletePackagingConfigurationResponse, RusotoError<DeletePackagingConfigurationError>>
{
let request_uri = format!("/packaging_configurations/{id}", id = input.id);
let mut request =
SignedRequest::new("DELETE", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeletePackagingConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeletePackagingConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_packaging_group(
&self,
input: DeletePackagingGroupRequest,
) -> Result<DeletePackagingGroupResponse, RusotoError<DeletePackagingGroupError>> {
let request_uri = format!("/packaging_groups/{id}", id = input.id);
let mut request =
SignedRequest::new("DELETE", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeletePackagingGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeletePackagingGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_asset(
&self,
input: DescribeAssetRequest,
) -> Result<DescribeAssetResponse, RusotoError<DescribeAssetError>> {
let request_uri = format!("/assets/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAssetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeAssetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_packaging_configuration(
&self,
input: DescribePackagingConfigurationRequest,
) -> Result<
DescribePackagingConfigurationResponse,
RusotoError<DescribePackagingConfigurationError>,
> {
let request_uri = format!("/packaging_configurations/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePackagingConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribePackagingConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_packaging_group(
&self,
input: DescribePackagingGroupRequest,
) -> Result<DescribePackagingGroupResponse, RusotoError<DescribePackagingGroupError>> {
let request_uri = format!("/packaging_groups/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePackagingGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribePackagingGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_assets(
&self,
input: ListAssetsRequest,
) -> Result<ListAssetsResponse, RusotoError<ListAssetsError>> {
let request_uri = "/assets";
let mut request = SignedRequest::new("GET", "mediapackage-vod", &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.packaging_group_id {
params.put("packagingGroupId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListAssetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListAssetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_packaging_configurations(
&self,
input: ListPackagingConfigurationsRequest,
) -> Result<ListPackagingConfigurationsResponse, RusotoError<ListPackagingConfigurationsError>>
{
let request_uri = "/packaging_configurations";
let mut request = SignedRequest::new("GET", "mediapackage-vod", &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.packaging_group_id {
params.put("packagingGroupId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPackagingConfigurationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPackagingConfigurationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_packaging_groups(
&self,
input: ListPackagingGroupsRequest,
) -> Result<ListPackagingGroupsResponse, RusotoError<ListPackagingGroupsError>> {
let request_uri = "/packaging_groups";
let mut request = SignedRequest::new("GET", "mediapackage-vod", &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);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPackagingGroupsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPackagingGroupsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request =
SignedRequest::new("POST", "mediapackage-vod", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request =
SignedRequest::new("DELETE", "mediapackage-vod", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_packaging_group(
&self,
input: UpdatePackagingGroupRequest,
) -> Result<UpdatePackagingGroupResponse, RusotoError<UpdatePackagingGroupError>> {
let request_uri = format!("/packaging_groups/{id}", id = input.id);
let mut request = SignedRequest::new("PUT", "mediapackage-vod", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePackagingGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdatePackagingGroupError::from_response(response))
}
}
}