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::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl PersonalizeClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "personalize", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Algorithm {
#[serde(rename = "algorithmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_arn: Option<String>,
#[serde(rename = "algorithmImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_image: Option<AlgorithmImage>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "defaultHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_hyper_parameter_ranges: Option<DefaultHyperParameterRanges>,
#[serde(rename = "defaultHyperParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_hyper_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "defaultResourceConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_resource_config: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "trainingInputMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub training_input_mode: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AlgorithmImage {
#[serde(rename = "dockerURI")]
pub docker_uri: String,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoMLConfig {
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
#[serde(rename = "recipeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoMLResult {
#[serde(rename = "bestRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub best_recipe_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchInferenceJob {
#[serde(rename = "batchInferenceJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_job_arn: Option<String>,
#[serde(rename = "batchInferenceJobConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_job_config: Option<BatchInferenceJobConfig>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "filterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_arn: Option<String>,
#[serde(rename = "jobInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_input: Option<BatchInferenceJobInput>,
#[serde(rename = "jobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "jobOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_output: Option<BatchInferenceJobOutput>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "numResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BatchInferenceJobConfig {
#[serde(rename = "itemExplorationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub item_exploration_config: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BatchInferenceJobInput {
#[serde(rename = "s3DataSource")]
pub s_3_data_source: S3DataConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BatchInferenceJobOutput {
#[serde(rename = "s3DataDestination")]
pub s_3_data_destination: S3DataConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchInferenceJobSummary {
#[serde(rename = "batchInferenceJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_job_arn: Option<String>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "jobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Campaign {
#[serde(rename = "campaignArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_arn: Option<String>,
#[serde(rename = "campaignConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_config: Option<CampaignConfig>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "latestCampaignUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_campaign_update: Option<CampaignUpdateSummary>,
#[serde(rename = "minProvisionedTPS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_provisioned_tps: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CampaignConfig {
#[serde(rename = "itemExplorationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub item_exploration_config: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CampaignSummary {
#[serde(rename = "campaignArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_arn: Option<String>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CampaignUpdateSummary {
#[serde(rename = "campaignConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_config: Option<CampaignConfig>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "minProvisionedTPS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_provisioned_tps: Option<i64>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CategoricalHyperParameterRange {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContinuousHyperParameterRange {
#[serde(rename = "maxValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_value: Option<f64>,
#[serde(rename = "minValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_value: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBatchInferenceJobRequest {
#[serde(rename = "batchInferenceJobConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_job_config: Option<BatchInferenceJobConfig>,
#[serde(rename = "filterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_arn: Option<String>,
#[serde(rename = "jobInput")]
pub job_input: BatchInferenceJobInput,
#[serde(rename = "jobName")]
pub job_name: String,
#[serde(rename = "jobOutput")]
pub job_output: BatchInferenceJobOutput,
#[serde(rename = "numResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
#[serde(rename = "roleArn")]
pub role_arn: String,
#[serde(rename = "solutionVersionArn")]
pub solution_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBatchInferenceJobResponse {
#[serde(rename = "batchInferenceJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_job_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCampaignRequest {
#[serde(rename = "campaignConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_config: Option<CampaignConfig>,
#[serde(rename = "minProvisionedTPS")]
pub min_provisioned_tps: i64,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "solutionVersionArn")]
pub solution_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCampaignResponse {
#[serde(rename = "campaignArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDatasetGroupRequest {
#[serde(rename = "kmsKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDatasetGroupResponse {
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDatasetImportJobRequest {
#[serde(rename = "dataSource")]
pub data_source: DataSource,
#[serde(rename = "datasetArn")]
pub dataset_arn: String,
#[serde(rename = "jobName")]
pub job_name: String,
#[serde(rename = "roleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDatasetImportJobResponse {
#[serde(rename = "datasetImportJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_import_job_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDatasetRequest {
#[serde(rename = "datasetGroupArn")]
pub dataset_group_arn: String,
#[serde(rename = "datasetType")]
pub dataset_type: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "schemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDatasetResponse {
#[serde(rename = "datasetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEventTrackerRequest {
#[serde(rename = "datasetGroupArn")]
pub dataset_group_arn: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEventTrackerResponse {
#[serde(rename = "eventTrackerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_tracker_arn: Option<String>,
#[serde(rename = "trackingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFilterRequest {
#[serde(rename = "datasetGroupArn")]
pub dataset_group_arn: String,
#[serde(rename = "filterExpression")]
pub filter_expression: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFilterResponse {
#[serde(rename = "filterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSchemaRequest {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "schema")]
pub schema: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSchemaResponse {
#[serde(rename = "schemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSolutionRequest {
#[serde(rename = "datasetGroupArn")]
pub dataset_group_arn: String,
#[serde(rename = "eventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "performAutoML")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_auto_ml: Option<bool>,
#[serde(rename = "performHPO")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_hpo: Option<bool>,
#[serde(rename = "recipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_arn: Option<String>,
#[serde(rename = "solutionConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_config: Option<SolutionConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSolutionResponse {
#[serde(rename = "solutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSolutionVersionRequest {
#[serde(rename = "solutionArn")]
pub solution_arn: String,
#[serde(rename = "trainingMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub training_mode: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSolutionVersionResponse {
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataSource {
#[serde(rename = "dataLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_location: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Dataset {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_arn: Option<String>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "datasetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_type: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "schemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetGroup {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "kmsKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetGroupSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetImportJob {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "dataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<DataSource>,
#[serde(rename = "datasetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_arn: Option<String>,
#[serde(rename = "datasetImportJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_import_job_arn: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "jobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetImportJobSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetImportJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_import_job_arn: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "jobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetSchema {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
#[serde(rename = "schemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetSchemaSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "schemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_arn: Option<String>,
#[serde(rename = "datasetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_type: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefaultCategoricalHyperParameterRange {
#[serde(rename = "isTunable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_tunable: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefaultContinuousHyperParameterRange {
#[serde(rename = "isTunable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_tunable: Option<bool>,
#[serde(rename = "maxValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_value: Option<f64>,
#[serde(rename = "minValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_value: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefaultHyperParameterRanges {
#[serde(rename = "categoricalHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub categorical_hyper_parameter_ranges: Option<Vec<DefaultCategoricalHyperParameterRange>>,
#[serde(rename = "continuousHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub continuous_hyper_parameter_ranges: Option<Vec<DefaultContinuousHyperParameterRange>>,
#[serde(rename = "integerHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integer_hyper_parameter_ranges: Option<Vec<DefaultIntegerHyperParameterRange>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefaultIntegerHyperParameterRange {
#[serde(rename = "isTunable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_tunable: Option<bool>,
#[serde(rename = "maxValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_value: Option<i64>,
#[serde(rename = "minValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_value: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCampaignRequest {
#[serde(rename = "campaignArn")]
pub campaign_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDatasetGroupRequest {
#[serde(rename = "datasetGroupArn")]
pub dataset_group_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDatasetRequest {
#[serde(rename = "datasetArn")]
pub dataset_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEventTrackerRequest {
#[serde(rename = "eventTrackerArn")]
pub event_tracker_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFilterRequest {
#[serde(rename = "filterArn")]
pub filter_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSchemaRequest {
#[serde(rename = "schemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSolutionRequest {
#[serde(rename = "solutionArn")]
pub solution_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAlgorithmRequest {
#[serde(rename = "algorithmArn")]
pub algorithm_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAlgorithmResponse {
#[serde(rename = "algorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm: Option<Algorithm>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeBatchInferenceJobRequest {
#[serde(rename = "batchInferenceJobArn")]
pub batch_inference_job_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeBatchInferenceJobResponse {
#[serde(rename = "batchInferenceJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_job: Option<BatchInferenceJob>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCampaignRequest {
#[serde(rename = "campaignArn")]
pub campaign_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCampaignResponse {
#[serde(rename = "campaign")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign: Option<Campaign>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDatasetGroupRequest {
#[serde(rename = "datasetGroupArn")]
pub dataset_group_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDatasetGroupResponse {
#[serde(rename = "datasetGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group: Option<DatasetGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDatasetImportJobRequest {
#[serde(rename = "datasetImportJobArn")]
pub dataset_import_job_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDatasetImportJobResponse {
#[serde(rename = "datasetImportJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_import_job: Option<DatasetImportJob>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDatasetRequest {
#[serde(rename = "datasetArn")]
pub dataset_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDatasetResponse {
#[serde(rename = "dataset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset: Option<Dataset>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEventTrackerRequest {
#[serde(rename = "eventTrackerArn")]
pub event_tracker_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEventTrackerResponse {
#[serde(rename = "eventTracker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_tracker: Option<EventTracker>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFeatureTransformationRequest {
#[serde(rename = "featureTransformationArn")]
pub feature_transformation_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFeatureTransformationResponse {
#[serde(rename = "featureTransformation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feature_transformation: Option<FeatureTransformation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFilterRequest {
#[serde(rename = "filterArn")]
pub filter_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFilterResponse {
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<Filter>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRecipeRequest {
#[serde(rename = "recipeArn")]
pub recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRecipeResponse {
#[serde(rename = "recipe")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe: Option<Recipe>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSchemaRequest {
#[serde(rename = "schemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSchemaResponse {
#[serde(rename = "schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<DatasetSchema>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSolutionRequest {
#[serde(rename = "solutionArn")]
pub solution_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSolutionResponse {
#[serde(rename = "solution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution: Option<Solution>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSolutionVersionRequest {
#[serde(rename = "solutionVersionArn")]
pub solution_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSolutionVersionResponse {
#[serde(rename = "solutionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version: Option<SolutionVersion>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventTracker {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "eventTrackerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_tracker_arn: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "trackingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventTrackerSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "eventTrackerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_tracker_arn: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FeatureTransformation {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "defaultParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "featureTransformationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feature_transformation_arn: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Filter {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "filterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_arn: Option<String>,
#[serde(rename = "filterExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_expression: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FilterSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "filterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_arn: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSolutionMetricsRequest {
#[serde(rename = "solutionVersionArn")]
pub solution_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSolutionMetricsResponse {
#[serde(rename = "metrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics: Option<::std::collections::HashMap<String, f64>>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HPOConfig {
#[serde(rename = "algorithmHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_hyper_parameter_ranges: Option<HyperParameterRanges>,
#[serde(rename = "hpoObjective")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hpo_objective: Option<HPOObjective>,
#[serde(rename = "hpoResourceConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hpo_resource_config: Option<HPOResourceConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HPOObjective {
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
#[serde(rename = "metricRegex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_regex: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HPOResourceConfig {
#[serde(rename = "maxNumberOfTrainingJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_number_of_training_jobs: Option<String>,
#[serde(rename = "maxParallelTrainingJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_parallel_training_jobs: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HyperParameterRanges {
#[serde(rename = "categoricalHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub categorical_hyper_parameter_ranges: Option<Vec<CategoricalHyperParameterRange>>,
#[serde(rename = "continuousHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub continuous_hyper_parameter_ranges: Option<Vec<ContinuousHyperParameterRange>>,
#[serde(rename = "integerHyperParameterRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integer_hyper_parameter_ranges: Option<Vec<IntegerHyperParameterRange>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct IntegerHyperParameterRange {
#[serde(rename = "maxValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_value: Option<i64>,
#[serde(rename = "minValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_value: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBatchInferenceJobsRequest {
#[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 = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBatchInferenceJobsResponse {
#[serde(rename = "batchInferenceJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_inference_jobs: Option<Vec<BatchInferenceJobSummary>>,
#[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 ListCampaignsRequest {
#[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 = "solutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCampaignsResponse {
#[serde(rename = "campaigns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaigns: Option<Vec<CampaignSummary>>,
#[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 ListDatasetGroupsRequest {
#[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 ListDatasetGroupsResponse {
#[serde(rename = "datasetGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_groups: Option<Vec<DatasetGroupSummary>>,
#[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 ListDatasetImportJobsRequest {
#[serde(rename = "datasetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_arn: 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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatasetImportJobsResponse {
#[serde(rename = "datasetImportJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_import_jobs: Option<Vec<DatasetImportJobSummary>>,
#[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 ListDatasetsRequest {
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: 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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatasetsResponse {
#[serde(rename = "datasets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datasets: Option<Vec<DatasetSummary>>,
#[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 ListEventTrackersRequest {
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: 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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEventTrackersResponse {
#[serde(rename = "eventTrackers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_trackers: Option<Vec<EventTrackerSummary>>,
#[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 ListFiltersRequest {
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: 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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFiltersResponse {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<FilterSummary>>,
#[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 ListRecipesRequest {
#[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 = "recipeProvider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_provider: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecipesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "recipes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipes: Option<Vec<RecipeSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSchemasRequest {
#[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 ListSchemasResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "schemas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schemas: Option<Vec<DatasetSchemaSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSolutionVersionsRequest {
#[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 = "solutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSolutionVersionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "solutionVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_versions: Option<Vec<SolutionVersionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSolutionsRequest {
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: 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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSolutionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "solutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solutions: Option<Vec<SolutionSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Recipe {
#[serde(rename = "algorithmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_arn: Option<String>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "featureTransformationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feature_transformation_arn: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "recipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_arn: Option<String>,
#[serde(rename = "recipeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecipeSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "recipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3DataConfig {
#[serde(rename = "kmsKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "path")]
pub path: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Solution {
#[serde(rename = "autoMLResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_ml_result: Option<AutoMLResult>,
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "eventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "latestSolutionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_solution_version: Option<SolutionVersionSummary>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "performAutoML")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_auto_ml: Option<bool>,
#[serde(rename = "performHPO")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_hpo: Option<bool>,
#[serde(rename = "recipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_arn: Option<String>,
#[serde(rename = "solutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_arn: Option<String>,
#[serde(rename = "solutionConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_config: Option<SolutionConfig>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SolutionConfig {
#[serde(rename = "algorithmHyperParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_hyper_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "autoMLConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_ml_config: Option<AutoMLConfig>,
#[serde(rename = "eventValueThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_value_threshold: Option<String>,
#[serde(rename = "featureTransformationParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feature_transformation_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "hpoConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hpo_config: Option<HPOConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SolutionSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "solutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SolutionVersion {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "datasetGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_group_arn: Option<String>,
#[serde(rename = "eventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "performAutoML")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_auto_ml: Option<bool>,
#[serde(rename = "performHPO")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_hpo: Option<bool>,
#[serde(rename = "recipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recipe_arn: Option<String>,
#[serde(rename = "solutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_arn: Option<String>,
#[serde(rename = "solutionConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_config: Option<SolutionConfig>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "trainingHours")]
#[serde(skip_serializing_if = "Option::is_none")]
pub training_hours: Option<f64>,
#[serde(rename = "trainingMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub training_mode: Option<String>,
#[serde(rename = "tunedHPOParams")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tuned_hpo_params: Option<TunedHPOParams>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SolutionVersionSummary {
#[serde(rename = "creationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TunedHPOParams {
#[serde(rename = "algorithmHyperParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm_hyper_parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCampaignRequest {
#[serde(rename = "campaignArn")]
pub campaign_arn: String,
#[serde(rename = "campaignConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_config: Option<CampaignConfig>,
#[serde(rename = "minProvisionedTPS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_provisioned_tps: Option<i64>,
#[serde(rename = "solutionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub solution_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCampaignResponse {
#[serde(rename = "campaignArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_arn: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateBatchInferenceJobError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateBatchInferenceJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBatchInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateBatchInferenceJobError::InvalidInput(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateBatchInferenceJobError::LimitExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateBatchInferenceJobError::ResourceAlreadyExists(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(CreateBatchInferenceJobError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateBatchInferenceJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBatchInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBatchInferenceJobError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateBatchInferenceJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateBatchInferenceJobError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateBatchInferenceJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateBatchInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBatchInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateCampaignError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateCampaignError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCampaignError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateCampaignError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateCampaignError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateCampaignError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateCampaignError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateCampaignError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCampaignError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCampaignError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateCampaignError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateCampaignError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateCampaignError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateCampaignError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCampaignError {}
#[derive(Debug, PartialEq)]
pub enum CreateDatasetError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDatasetError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateDatasetError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDatasetError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateDatasetError::ResourceAlreadyExists(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateDatasetError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateDatasetError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDatasetError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDatasetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDatasetError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDatasetError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDatasetError {}
#[derive(Debug, PartialEq)]
pub enum CreateDatasetGroupError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
}
impl CreateDatasetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDatasetGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateDatasetGroupError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDatasetGroupError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateDatasetGroupError::ResourceAlreadyExists(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDatasetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDatasetGroupError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDatasetGroupError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDatasetGroupError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDatasetGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateDatasetImportJobError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateDatasetImportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDatasetImportJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateDatasetImportJobError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDatasetImportJobError::LimitExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateDatasetImportJobError::ResourceAlreadyExists(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(CreateDatasetImportJobError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateDatasetImportJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDatasetImportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDatasetImportJobError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDatasetImportJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDatasetImportJobError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDatasetImportJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateDatasetImportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDatasetImportJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateEventTrackerError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateEventTrackerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEventTrackerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateEventTrackerError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateEventTrackerError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateEventTrackerError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateEventTrackerError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateEventTrackerError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEventTrackerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEventTrackerError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateEventTrackerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateEventTrackerError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateEventTrackerError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateEventTrackerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEventTrackerError {}
#[derive(Debug, PartialEq)]
pub enum CreateFilterError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
}
impl CreateFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateFilterError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateFilterError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateFilterError::ResourceAlreadyExists(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateFilterError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFilterError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateFilterError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateFilterError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateFilterError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFilterError {}
#[derive(Debug, PartialEq)]
pub enum CreateSchemaError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
}
impl CreateSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSchemaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateSchemaError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateSchemaError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateSchemaError::ResourceAlreadyExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSchemaError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateSchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSchemaError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSchemaError {}
#[derive(Debug, PartialEq)]
pub enum CreateSolutionError {
InvalidInput(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateSolutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSolutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateSolutionError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateSolutionError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateSolutionError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateSolutionError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateSolutionError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSolutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSolutionError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateSolutionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSolutionError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateSolutionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateSolutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSolutionError {}
#[derive(Debug, PartialEq)]
pub enum CreateSolutionVersionError {
InvalidInput(String),
LimitExceeded(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateSolutionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSolutionVersionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(CreateSolutionVersionError::InvalidInput(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateSolutionVersionError::LimitExceeded(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateSolutionVersionError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateSolutionVersionError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSolutionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSolutionVersionError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateSolutionVersionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSolutionVersionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateSolutionVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSolutionVersionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCampaignError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteCampaignError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCampaignError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteCampaignError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteCampaignError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteCampaignError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCampaignError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCampaignError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteCampaignError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteCampaignError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCampaignError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDatasetError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDatasetError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteDatasetError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteDatasetError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDatasetError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDatasetError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDatasetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDatasetGroupError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteDatasetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDatasetGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteDatasetGroupError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteDatasetGroupError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDatasetGroupError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDatasetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDatasetGroupError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDatasetGroupError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteDatasetGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDatasetGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEventTrackerError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteEventTrackerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEventTrackerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteEventTrackerError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteEventTrackerError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteEventTrackerError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEventTrackerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEventTrackerError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteEventTrackerError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteEventTrackerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEventTrackerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFilterError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteFilterError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteFilterError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteFilterError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFilterError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteFilterError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteFilterError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFilterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSchemaError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSchemaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteSchemaError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteSchemaError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteSchemaError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSchemaError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSchemaError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSolutionError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteSolutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSolutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DeleteSolutionError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteSolutionError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteSolutionError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSolutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSolutionError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteSolutionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteSolutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSolutionError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAlgorithmError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeAlgorithmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAlgorithmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeAlgorithmError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeAlgorithmError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAlgorithmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAlgorithmError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeAlgorithmError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAlgorithmError {}
#[derive(Debug, PartialEq)]
pub enum DescribeBatchInferenceJobError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeBatchInferenceJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeBatchInferenceJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeBatchInferenceJobError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeBatchInferenceJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeBatchInferenceJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeBatchInferenceJobError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeBatchInferenceJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeBatchInferenceJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCampaignError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeCampaignError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCampaignError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeCampaignError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeCampaignError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCampaignError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCampaignError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeCampaignError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCampaignError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDatasetError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDatasetError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeDatasetError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDatasetError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDatasetError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDatasetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDatasetGroupError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeDatasetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDatasetGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeDatasetGroupError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDatasetGroupError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDatasetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDatasetGroupError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeDatasetGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDatasetGroupError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDatasetImportJobError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeDatasetImportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDatasetImportJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeDatasetImportJobError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDatasetImportJobError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDatasetImportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDatasetImportJobError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeDatasetImportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDatasetImportJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEventTrackerError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeEventTrackerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEventTrackerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeEventTrackerError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeEventTrackerError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEventTrackerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEventTrackerError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeEventTrackerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeEventTrackerError {}
#[derive(Debug, PartialEq)]
pub enum DescribeFeatureTransformationError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeFeatureTransformationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeFeatureTransformationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeFeatureTransformationError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeFeatureTransformationError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeFeatureTransformationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeFeatureTransformationError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeFeatureTransformationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeFeatureTransformationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeFilterError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFilterError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeFilterError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeFilterError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeFilterError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeFilterError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeFilterError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRecipeError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRecipeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeRecipeError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRecipeError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRecipeError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeRecipeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRecipeError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSchemaError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSchemaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeSchemaError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeSchemaError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSchemaError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSchemaError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSolutionError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeSolutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSolutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeSolutionError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeSolutionError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSolutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSolutionError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeSolutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSolutionError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSolutionVersionError {
InvalidInput(String),
ResourceNotFound(String),
}
impl DescribeSolutionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSolutionVersionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(DescribeSolutionVersionError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeSolutionVersionError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSolutionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSolutionVersionError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeSolutionVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSolutionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetSolutionMetricsError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl GetSolutionMetricsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSolutionMetricsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(GetSolutionMetricsError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(GetSolutionMetricsError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSolutionMetricsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSolutionMetricsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSolutionMetricsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetSolutionMetricsError::ResourceInUse(ref cause) => write!(f, "{}", cause),
GetSolutionMetricsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSolutionMetricsError {}
#[derive(Debug, PartialEq)]
pub enum ListBatchInferenceJobsError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListBatchInferenceJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBatchInferenceJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListBatchInferenceJobsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListBatchInferenceJobsError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBatchInferenceJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBatchInferenceJobsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListBatchInferenceJobsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBatchInferenceJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListCampaignsError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListCampaignsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCampaignsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListCampaignsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListCampaignsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCampaignsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCampaignsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListCampaignsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCampaignsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatasetGroupsError {
InvalidNextToken(String),
}
impl ListDatasetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatasetGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListDatasetGroupsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatasetGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatasetGroupsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatasetGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatasetImportJobsError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListDatasetImportJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatasetImportJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListDatasetImportJobsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDatasetImportJobsError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatasetImportJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatasetImportJobsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListDatasetImportJobsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatasetImportJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatasetsError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListDatasetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatasetsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListDatasetsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDatasetsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatasetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatasetsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListDatasetsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatasetsError {}
#[derive(Debug, PartialEq)]
pub enum ListEventTrackersError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListEventTrackersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEventTrackersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListEventTrackersError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListEventTrackersError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEventTrackersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEventTrackersError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListEventTrackersError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEventTrackersError {}
#[derive(Debug, PartialEq)]
pub enum ListFiltersError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListFiltersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFiltersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListFiltersError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListFiltersError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFiltersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFiltersError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListFiltersError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFiltersError {}
#[derive(Debug, PartialEq)]
pub enum ListRecipesError {
InvalidNextToken(String),
}
impl ListRecipesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRecipesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListRecipesError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecipesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecipesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRecipesError {}
#[derive(Debug, PartialEq)]
pub enum ListSchemasError {
InvalidNextToken(String),
}
impl ListSchemasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSchemasError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListSchemasError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSchemasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSchemasError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSchemasError {}
#[derive(Debug, PartialEq)]
pub enum ListSolutionVersionsError {
InvalidInput(String),
InvalidNextToken(String),
ResourceNotFound(String),
}
impl ListSolutionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSolutionVersionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListSolutionVersionsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListSolutionVersionsError::InvalidNextToken(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListSolutionVersionsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSolutionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSolutionVersionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListSolutionVersionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListSolutionVersionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSolutionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListSolutionsError {
InvalidInput(String),
InvalidNextToken(String),
}
impl ListSolutionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSolutionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(ListSolutionsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListSolutionsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSolutionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSolutionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListSolutionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSolutionsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCampaignError {
InvalidInput(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl UpdateCampaignError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateCampaignError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(UpdateCampaignError::InvalidInput(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(UpdateCampaignError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateCampaignError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCampaignError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCampaignError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateCampaignError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UpdateCampaignError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateCampaignError {}
#[async_trait]
pub trait Personalize {
async fn create_batch_inference_job(
&self,
input: CreateBatchInferenceJobRequest,
) -> Result<CreateBatchInferenceJobResponse, RusotoError<CreateBatchInferenceJobError>>;
async fn create_campaign(
&self,
input: CreateCampaignRequest,
) -> Result<CreateCampaignResponse, RusotoError<CreateCampaignError>>;
async fn create_dataset(
&self,
input: CreateDatasetRequest,
) -> Result<CreateDatasetResponse, RusotoError<CreateDatasetError>>;
async fn create_dataset_group(
&self,
input: CreateDatasetGroupRequest,
) -> Result<CreateDatasetGroupResponse, RusotoError<CreateDatasetGroupError>>;
async fn create_dataset_import_job(
&self,
input: CreateDatasetImportJobRequest,
) -> Result<CreateDatasetImportJobResponse, RusotoError<CreateDatasetImportJobError>>;
async fn create_event_tracker(
&self,
input: CreateEventTrackerRequest,
) -> Result<CreateEventTrackerResponse, RusotoError<CreateEventTrackerError>>;
async fn create_filter(
&self,
input: CreateFilterRequest,
) -> Result<CreateFilterResponse, RusotoError<CreateFilterError>>;
async fn create_schema(
&self,
input: CreateSchemaRequest,
) -> Result<CreateSchemaResponse, RusotoError<CreateSchemaError>>;
async fn create_solution(
&self,
input: CreateSolutionRequest,
) -> Result<CreateSolutionResponse, RusotoError<CreateSolutionError>>;
async fn create_solution_version(
&self,
input: CreateSolutionVersionRequest,
) -> Result<CreateSolutionVersionResponse, RusotoError<CreateSolutionVersionError>>;
async fn delete_campaign(
&self,
input: DeleteCampaignRequest,
) -> Result<(), RusotoError<DeleteCampaignError>>;
async fn delete_dataset(
&self,
input: DeleteDatasetRequest,
) -> Result<(), RusotoError<DeleteDatasetError>>;
async fn delete_dataset_group(
&self,
input: DeleteDatasetGroupRequest,
) -> Result<(), RusotoError<DeleteDatasetGroupError>>;
async fn delete_event_tracker(
&self,
input: DeleteEventTrackerRequest,
) -> Result<(), RusotoError<DeleteEventTrackerError>>;
async fn delete_filter(
&self,
input: DeleteFilterRequest,
) -> Result<(), RusotoError<DeleteFilterError>>;
async fn delete_schema(
&self,
input: DeleteSchemaRequest,
) -> Result<(), RusotoError<DeleteSchemaError>>;
async fn delete_solution(
&self,
input: DeleteSolutionRequest,
) -> Result<(), RusotoError<DeleteSolutionError>>;
async fn describe_algorithm(
&self,
input: DescribeAlgorithmRequest,
) -> Result<DescribeAlgorithmResponse, RusotoError<DescribeAlgorithmError>>;
async fn describe_batch_inference_job(
&self,
input: DescribeBatchInferenceJobRequest,
) -> Result<DescribeBatchInferenceJobResponse, RusotoError<DescribeBatchInferenceJobError>>;
async fn describe_campaign(
&self,
input: DescribeCampaignRequest,
) -> Result<DescribeCampaignResponse, RusotoError<DescribeCampaignError>>;
async fn describe_dataset(
&self,
input: DescribeDatasetRequest,
) -> Result<DescribeDatasetResponse, RusotoError<DescribeDatasetError>>;
async fn describe_dataset_group(
&self,
input: DescribeDatasetGroupRequest,
) -> Result<DescribeDatasetGroupResponse, RusotoError<DescribeDatasetGroupError>>;
async fn describe_dataset_import_job(
&self,
input: DescribeDatasetImportJobRequest,
) -> Result<DescribeDatasetImportJobResponse, RusotoError<DescribeDatasetImportJobError>>;
async fn describe_event_tracker(
&self,
input: DescribeEventTrackerRequest,
) -> Result<DescribeEventTrackerResponse, RusotoError<DescribeEventTrackerError>>;
async fn describe_feature_transformation(
&self,
input: DescribeFeatureTransformationRequest,
) -> Result<
DescribeFeatureTransformationResponse,
RusotoError<DescribeFeatureTransformationError>,
>;
async fn describe_filter(
&self,
input: DescribeFilterRequest,
) -> Result<DescribeFilterResponse, RusotoError<DescribeFilterError>>;
async fn describe_recipe(
&self,
input: DescribeRecipeRequest,
) -> Result<DescribeRecipeResponse, RusotoError<DescribeRecipeError>>;
async fn describe_schema(
&self,
input: DescribeSchemaRequest,
) -> Result<DescribeSchemaResponse, RusotoError<DescribeSchemaError>>;
async fn describe_solution(
&self,
input: DescribeSolutionRequest,
) -> Result<DescribeSolutionResponse, RusotoError<DescribeSolutionError>>;
async fn describe_solution_version(
&self,
input: DescribeSolutionVersionRequest,
) -> Result<DescribeSolutionVersionResponse, RusotoError<DescribeSolutionVersionError>>;
async fn get_solution_metrics(
&self,
input: GetSolutionMetricsRequest,
) -> Result<GetSolutionMetricsResponse, RusotoError<GetSolutionMetricsError>>;
async fn list_batch_inference_jobs(
&self,
input: ListBatchInferenceJobsRequest,
) -> Result<ListBatchInferenceJobsResponse, RusotoError<ListBatchInferenceJobsError>>;
async fn list_campaigns(
&self,
input: ListCampaignsRequest,
) -> Result<ListCampaignsResponse, RusotoError<ListCampaignsError>>;
async fn list_dataset_groups(
&self,
input: ListDatasetGroupsRequest,
) -> Result<ListDatasetGroupsResponse, RusotoError<ListDatasetGroupsError>>;
async fn list_dataset_import_jobs(
&self,
input: ListDatasetImportJobsRequest,
) -> Result<ListDatasetImportJobsResponse, RusotoError<ListDatasetImportJobsError>>;
async fn list_datasets(
&self,
input: ListDatasetsRequest,
) -> Result<ListDatasetsResponse, RusotoError<ListDatasetsError>>;
async fn list_event_trackers(
&self,
input: ListEventTrackersRequest,
) -> Result<ListEventTrackersResponse, RusotoError<ListEventTrackersError>>;
async fn list_filters(
&self,
input: ListFiltersRequest,
) -> Result<ListFiltersResponse, RusotoError<ListFiltersError>>;
async fn list_recipes(
&self,
input: ListRecipesRequest,
) -> Result<ListRecipesResponse, RusotoError<ListRecipesError>>;
async fn list_schemas(
&self,
input: ListSchemasRequest,
) -> Result<ListSchemasResponse, RusotoError<ListSchemasError>>;
async fn list_solution_versions(
&self,
input: ListSolutionVersionsRequest,
) -> Result<ListSolutionVersionsResponse, RusotoError<ListSolutionVersionsError>>;
async fn list_solutions(
&self,
input: ListSolutionsRequest,
) -> Result<ListSolutionsResponse, RusotoError<ListSolutionsError>>;
async fn update_campaign(
&self,
input: UpdateCampaignRequest,
) -> Result<UpdateCampaignResponse, RusotoError<UpdateCampaignError>>;
}
#[derive(Clone)]
pub struct PersonalizeClient {
client: Client,
region: region::Region,
}
impl PersonalizeClient {
pub fn new(region: region::Region) -> PersonalizeClient {
PersonalizeClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> PersonalizeClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
PersonalizeClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> PersonalizeClient {
PersonalizeClient { client, region }
}
}
#[async_trait]
impl Personalize for PersonalizeClient {
async fn create_batch_inference_job(
&self,
input: CreateBatchInferenceJobRequest,
) -> Result<CreateBatchInferenceJobResponse, RusotoError<CreateBatchInferenceJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateBatchInferenceJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateBatchInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateBatchInferenceJobResponse, _>()
}
async fn create_campaign(
&self,
input: CreateCampaignRequest,
) -> Result<CreateCampaignResponse, RusotoError<CreateCampaignError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateCampaign");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateCampaignError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateCampaignResponse, _>()
}
async fn create_dataset(
&self,
input: CreateDatasetRequest,
) -> Result<CreateDatasetResponse, RusotoError<CreateDatasetError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateDataset");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDatasetError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDatasetResponse, _>()
}
async fn create_dataset_group(
&self,
input: CreateDatasetGroupRequest,
) -> Result<CreateDatasetGroupResponse, RusotoError<CreateDatasetGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateDatasetGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDatasetGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDatasetGroupResponse, _>()
}
async fn create_dataset_import_job(
&self,
input: CreateDatasetImportJobRequest,
) -> Result<CreateDatasetImportJobResponse, RusotoError<CreateDatasetImportJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateDatasetImportJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDatasetImportJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDatasetImportJobResponse, _>()
}
async fn create_event_tracker(
&self,
input: CreateEventTrackerRequest,
) -> Result<CreateEventTrackerResponse, RusotoError<CreateEventTrackerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateEventTracker");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateEventTrackerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateEventTrackerResponse, _>()
}
async fn create_filter(
&self,
input: CreateFilterRequest,
) -> Result<CreateFilterResponse, RusotoError<CreateFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateFilterError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateFilterResponse, _>()
}
async fn create_schema(
&self,
input: CreateSchemaRequest,
) -> Result<CreateSchemaResponse, RusotoError<CreateSchemaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateSchema");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateSchemaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateSchemaResponse, _>()
}
async fn create_solution(
&self,
input: CreateSolutionRequest,
) -> Result<CreateSolutionResponse, RusotoError<CreateSolutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateSolution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateSolutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateSolutionResponse, _>()
}
async fn create_solution_version(
&self,
input: CreateSolutionVersionRequest,
) -> Result<CreateSolutionVersionResponse, RusotoError<CreateSolutionVersionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.CreateSolutionVersion");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateSolutionVersionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSolutionVersionResponse, _>()
}
async fn delete_campaign(
&self,
input: DeleteCampaignRequest,
) -> Result<(), RusotoError<DeleteCampaignError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteCampaign");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteCampaignError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_dataset(
&self,
input: DeleteDatasetRequest,
) -> Result<(), RusotoError<DeleteDatasetError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteDataset");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDatasetError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_dataset_group(
&self,
input: DeleteDatasetGroupRequest,
) -> Result<(), RusotoError<DeleteDatasetGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteDatasetGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDatasetGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_event_tracker(
&self,
input: DeleteEventTrackerRequest,
) -> Result<(), RusotoError<DeleteEventTrackerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteEventTracker");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteEventTrackerError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_filter(
&self,
input: DeleteFilterRequest,
) -> Result<(), RusotoError<DeleteFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteFilterError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_schema(
&self,
input: DeleteSchemaRequest,
) -> Result<(), RusotoError<DeleteSchemaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteSchema");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteSchemaError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_solution(
&self,
input: DeleteSolutionRequest,
) -> Result<(), RusotoError<DeleteSolutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DeleteSolution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteSolutionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn describe_algorithm(
&self,
input: DescribeAlgorithmRequest,
) -> Result<DescribeAlgorithmResponse, RusotoError<DescribeAlgorithmError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeAlgorithm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeAlgorithmError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeAlgorithmResponse, _>()
}
async fn describe_batch_inference_job(
&self,
input: DescribeBatchInferenceJobRequest,
) -> Result<DescribeBatchInferenceJobResponse, RusotoError<DescribeBatchInferenceJobError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AmazonPersonalize.DescribeBatchInferenceJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeBatchInferenceJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeBatchInferenceJobResponse, _>()
}
async fn describe_campaign(
&self,
input: DescribeCampaignRequest,
) -> Result<DescribeCampaignResponse, RusotoError<DescribeCampaignError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeCampaign");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeCampaignError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeCampaignResponse, _>()
}
async fn describe_dataset(
&self,
input: DescribeDatasetRequest,
) -> Result<DescribeDatasetResponse, RusotoError<DescribeDatasetError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeDataset");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDatasetError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeDatasetResponse, _>()
}
async fn describe_dataset_group(
&self,
input: DescribeDatasetGroupRequest,
) -> Result<DescribeDatasetGroupResponse, RusotoError<DescribeDatasetGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeDatasetGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDatasetGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDatasetGroupResponse, _>()
}
async fn describe_dataset_import_job(
&self,
input: DescribeDatasetImportJobRequest,
) -> Result<DescribeDatasetImportJobResponse, RusotoError<DescribeDatasetImportJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeDatasetImportJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDatasetImportJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDatasetImportJobResponse, _>()
}
async fn describe_event_tracker(
&self,
input: DescribeEventTrackerRequest,
) -> Result<DescribeEventTrackerResponse, RusotoError<DescribeEventTrackerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeEventTracker");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEventTrackerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeEventTrackerResponse, _>()
}
async fn describe_feature_transformation(
&self,
input: DescribeFeatureTransformationRequest,
) -> Result<
DescribeFeatureTransformationResponse,
RusotoError<DescribeFeatureTransformationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AmazonPersonalize.DescribeFeatureTransformation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeFeatureTransformationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeFeatureTransformationResponse, _>()
}
async fn describe_filter(
&self,
input: DescribeFilterRequest,
) -> Result<DescribeFilterResponse, RusotoError<DescribeFilterError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeFilter");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeFilterError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeFilterResponse, _>()
}
async fn describe_recipe(
&self,
input: DescribeRecipeRequest,
) -> Result<DescribeRecipeResponse, RusotoError<DescribeRecipeError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeRecipe");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeRecipeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeRecipeResponse, _>()
}
async fn describe_schema(
&self,
input: DescribeSchemaRequest,
) -> Result<DescribeSchemaResponse, RusotoError<DescribeSchemaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeSchema");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeSchemaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeSchemaResponse, _>()
}
async fn describe_solution(
&self,
input: DescribeSolutionRequest,
) -> Result<DescribeSolutionResponse, RusotoError<DescribeSolutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeSolution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeSolutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeSolutionResponse, _>()
}
async fn describe_solution_version(
&self,
input: DescribeSolutionVersionRequest,
) -> Result<DescribeSolutionVersionResponse, RusotoError<DescribeSolutionVersionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.DescribeSolutionVersion");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeSolutionVersionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSolutionVersionResponse, _>()
}
async fn get_solution_metrics(
&self,
input: GetSolutionMetricsRequest,
) -> Result<GetSolutionMetricsResponse, RusotoError<GetSolutionMetricsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.GetSolutionMetrics");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSolutionMetricsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetSolutionMetricsResponse, _>()
}
async fn list_batch_inference_jobs(
&self,
input: ListBatchInferenceJobsRequest,
) -> Result<ListBatchInferenceJobsResponse, RusotoError<ListBatchInferenceJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListBatchInferenceJobs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListBatchInferenceJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListBatchInferenceJobsResponse, _>()
}
async fn list_campaigns(
&self,
input: ListCampaignsRequest,
) -> Result<ListCampaignsResponse, RusotoError<ListCampaignsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListCampaigns");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCampaignsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListCampaignsResponse, _>()
}
async fn list_dataset_groups(
&self,
input: ListDatasetGroupsRequest,
) -> Result<ListDatasetGroupsResponse, RusotoError<ListDatasetGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListDatasetGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDatasetGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDatasetGroupsResponse, _>()
}
async fn list_dataset_import_jobs(
&self,
input: ListDatasetImportJobsRequest,
) -> Result<ListDatasetImportJobsResponse, RusotoError<ListDatasetImportJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListDatasetImportJobs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDatasetImportJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListDatasetImportJobsResponse, _>()
}
async fn list_datasets(
&self,
input: ListDatasetsRequest,
) -> Result<ListDatasetsResponse, RusotoError<ListDatasetsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListDatasets");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDatasetsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDatasetsResponse, _>()
}
async fn list_event_trackers(
&self,
input: ListEventTrackersRequest,
) -> Result<ListEventTrackersResponse, RusotoError<ListEventTrackersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListEventTrackers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListEventTrackersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListEventTrackersResponse, _>()
}
async fn list_filters(
&self,
input: ListFiltersRequest,
) -> Result<ListFiltersResponse, RusotoError<ListFiltersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListFilters");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListFiltersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListFiltersResponse, _>()
}
async fn list_recipes(
&self,
input: ListRecipesRequest,
) -> Result<ListRecipesResponse, RusotoError<ListRecipesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListRecipes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListRecipesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListRecipesResponse, _>()
}
async fn list_schemas(
&self,
input: ListSchemasRequest,
) -> Result<ListSchemasResponse, RusotoError<ListSchemasError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListSchemas");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListSchemasError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListSchemasResponse, _>()
}
async fn list_solution_versions(
&self,
input: ListSolutionVersionsRequest,
) -> Result<ListSolutionVersionsResponse, RusotoError<ListSolutionVersionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListSolutionVersions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListSolutionVersionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListSolutionVersionsResponse, _>()
}
async fn list_solutions(
&self,
input: ListSolutionsRequest,
) -> Result<ListSolutionsResponse, RusotoError<ListSolutionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.ListSolutions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListSolutionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListSolutionsResponse, _>()
}
async fn update_campaign(
&self,
input: UpdateCampaignRequest,
) -> Result<UpdateCampaignResponse, RusotoError<UpdateCampaignError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonPersonalize.UpdateCampaign");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateCampaignError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateCampaignResponse, _>()
}
}