#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeploymentResult {
#[doc(hidden)]
pub deployment_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_status: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_status_message: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_start_time: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub deployment_end_time: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub deployment_models: std::option::Option<std::vec::Vec<crate::model::DeploymentModel>>,
}
impl DeploymentResult {
pub fn deployment_name(&self) -> std::option::Option<&str> {
self.deployment_name.as_deref()
}
pub fn deployment_status(&self) -> std::option::Option<&str> {
self.deployment_status.as_deref()
}
pub fn deployment_status_message(&self) -> std::option::Option<&str> {
self.deployment_status_message.as_deref()
}
pub fn deployment_start_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.deployment_start_time.as_ref()
}
pub fn deployment_end_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.deployment_end_time.as_ref()
}
pub fn deployment_models(&self) -> std::option::Option<&[crate::model::DeploymentModel]> {
self.deployment_models.as_deref()
}
}
pub mod deployment_result {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) deployment_name: std::option::Option<std::string::String>,
pub(crate) deployment_status: std::option::Option<std::string::String>,
pub(crate) deployment_status_message: std::option::Option<std::string::String>,
pub(crate) deployment_start_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) deployment_end_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) deployment_models:
std::option::Option<std::vec::Vec<crate::model::DeploymentModel>>,
}
impl Builder {
pub fn deployment_name(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_name = Some(input.into());
self
}
pub fn set_deployment_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_name = input;
self
}
pub fn deployment_status(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_status = Some(input.into());
self
}
pub fn set_deployment_status(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_status = input;
self
}
pub fn deployment_status_message(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_status_message = Some(input.into());
self
}
pub fn set_deployment_status_message(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_status_message = input;
self
}
pub fn deployment_start_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.deployment_start_time = Some(input);
self
}
pub fn set_deployment_start_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.deployment_start_time = input;
self
}
pub fn deployment_end_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.deployment_end_time = Some(input);
self
}
pub fn set_deployment_end_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.deployment_end_time = input;
self
}
pub fn deployment_models(mut self, input: crate::model::DeploymentModel) -> Self {
let mut v = self.deployment_models.unwrap_or_default();
v.push(input);
self.deployment_models = Some(v);
self
}
pub fn set_deployment_models(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DeploymentModel>>,
) -> Self {
self.deployment_models = input;
self
}
pub fn build(self) -> crate::model::DeploymentResult {
crate::model::DeploymentResult {
deployment_name: self.deployment_name,
deployment_status: self.deployment_status,
deployment_status_message: self.deployment_status_message,
deployment_start_time: self.deployment_start_time,
deployment_end_time: self.deployment_end_time,
deployment_models: self.deployment_models,
}
}
}
}
impl DeploymentResult {
pub fn builder() -> crate::model::deployment_result::Builder {
crate::model::deployment_result::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeploymentModel {
#[doc(hidden)]
pub model_handle: std::option::Option<std::string::String>,
#[doc(hidden)]
pub model_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub model_version: std::option::Option<std::string::String>,
#[doc(hidden)]
pub desired_state: std::option::Option<crate::model::ModelState>,
#[doc(hidden)]
pub state: std::option::Option<crate::model::ModelState>,
#[doc(hidden)]
pub status: std::option::Option<crate::model::DeploymentStatus>,
#[doc(hidden)]
pub status_reason: std::option::Option<std::string::String>,
#[doc(hidden)]
pub rollback_failure_reason: std::option::Option<std::string::String>,
}
impl DeploymentModel {
pub fn model_handle(&self) -> std::option::Option<&str> {
self.model_handle.as_deref()
}
pub fn model_name(&self) -> std::option::Option<&str> {
self.model_name.as_deref()
}
pub fn model_version(&self) -> std::option::Option<&str> {
self.model_version.as_deref()
}
pub fn desired_state(&self) -> std::option::Option<&crate::model::ModelState> {
self.desired_state.as_ref()
}
pub fn state(&self) -> std::option::Option<&crate::model::ModelState> {
self.state.as_ref()
}
pub fn status(&self) -> std::option::Option<&crate::model::DeploymentStatus> {
self.status.as_ref()
}
pub fn status_reason(&self) -> std::option::Option<&str> {
self.status_reason.as_deref()
}
pub fn rollback_failure_reason(&self) -> std::option::Option<&str> {
self.rollback_failure_reason.as_deref()
}
}
pub mod deployment_model {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) model_handle: std::option::Option<std::string::String>,
pub(crate) model_name: std::option::Option<std::string::String>,
pub(crate) model_version: std::option::Option<std::string::String>,
pub(crate) desired_state: std::option::Option<crate::model::ModelState>,
pub(crate) state: std::option::Option<crate::model::ModelState>,
pub(crate) status: std::option::Option<crate::model::DeploymentStatus>,
pub(crate) status_reason: std::option::Option<std::string::String>,
pub(crate) rollback_failure_reason: std::option::Option<std::string::String>,
}
impl Builder {
pub fn model_handle(mut self, input: impl Into<std::string::String>) -> Self {
self.model_handle = Some(input.into());
self
}
pub fn set_model_handle(mut self, input: std::option::Option<std::string::String>) -> Self {
self.model_handle = input;
self
}
pub fn model_name(mut self, input: impl Into<std::string::String>) -> Self {
self.model_name = Some(input.into());
self
}
pub fn set_model_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.model_name = input;
self
}
pub fn model_version(mut self, input: impl Into<std::string::String>) -> Self {
self.model_version = Some(input.into());
self
}
pub fn set_model_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.model_version = input;
self
}
pub fn desired_state(mut self, input: crate::model::ModelState) -> Self {
self.desired_state = Some(input);
self
}
pub fn set_desired_state(
mut self,
input: std::option::Option<crate::model::ModelState>,
) -> Self {
self.desired_state = input;
self
}
pub fn state(mut self, input: crate::model::ModelState) -> Self {
self.state = Some(input);
self
}
pub fn set_state(mut self, input: std::option::Option<crate::model::ModelState>) -> Self {
self.state = input;
self
}
pub fn status(mut self, input: crate::model::DeploymentStatus) -> Self {
self.status = Some(input);
self
}
pub fn set_status(
mut self,
input: std::option::Option<crate::model::DeploymentStatus>,
) -> Self {
self.status = input;
self
}
pub fn status_reason(mut self, input: impl Into<std::string::String>) -> Self {
self.status_reason = Some(input.into());
self
}
pub fn set_status_reason(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.status_reason = input;
self
}
pub fn rollback_failure_reason(mut self, input: impl Into<std::string::String>) -> Self {
self.rollback_failure_reason = Some(input.into());
self
}
pub fn set_rollback_failure_reason(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.rollback_failure_reason = input;
self
}
pub fn build(self) -> crate::model::DeploymentModel {
crate::model::DeploymentModel {
model_handle: self.model_handle,
model_name: self.model_name,
model_version: self.model_version,
desired_state: self.desired_state,
state: self.state,
status: self.status,
status_reason: self.status_reason,
rollback_failure_reason: self.rollback_failure_reason,
}
}
}
}
impl DeploymentModel {
pub fn builder() -> crate::model::deployment_model::Builder {
crate::model::deployment_model::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DeploymentStatus {
#[allow(missing_docs)] Fail,
#[allow(missing_docs)] Success,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for DeploymentStatus {
fn from(s: &str) -> Self {
match s {
"FAIL" => DeploymentStatus::Fail,
"SUCCESS" => DeploymentStatus::Success,
other => DeploymentStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for DeploymentStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DeploymentStatus::from(s))
}
}
impl DeploymentStatus {
pub fn as_str(&self) -> &str {
match self {
DeploymentStatus::Fail => "FAIL",
DeploymentStatus::Success => "SUCCESS",
DeploymentStatus::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["FAIL", "SUCCESS"]
}
}
impl AsRef<str> for DeploymentStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum ModelState {
#[allow(missing_docs)] Deploy,
#[allow(missing_docs)] Undeploy,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ModelState {
fn from(s: &str) -> Self {
match s {
"DEPLOY" => ModelState::Deploy,
"UNDEPLOY" => ModelState::Undeploy,
other => ModelState::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for ModelState {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ModelState::from(s))
}
}
impl ModelState {
pub fn as_str(&self) -> &str {
match self {
ModelState::Deploy => "DEPLOY",
ModelState::Undeploy => "UNDEPLOY",
ModelState::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["DEPLOY", "UNDEPLOY"]
}
}
impl AsRef<str> for ModelState {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Model {
#[doc(hidden)]
pub model_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub model_version: std::option::Option<std::string::String>,
#[doc(hidden)]
pub latest_sample_time: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub latest_inference: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub model_metrics: std::option::Option<std::vec::Vec<crate::model::EdgeMetric>>,
}
impl Model {
pub fn model_name(&self) -> std::option::Option<&str> {
self.model_name.as_deref()
}
pub fn model_version(&self) -> std::option::Option<&str> {
self.model_version.as_deref()
}
pub fn latest_sample_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.latest_sample_time.as_ref()
}
pub fn latest_inference(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.latest_inference.as_ref()
}
pub fn model_metrics(&self) -> std::option::Option<&[crate::model::EdgeMetric]> {
self.model_metrics.as_deref()
}
}
pub mod model {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) model_name: std::option::Option<std::string::String>,
pub(crate) model_version: std::option::Option<std::string::String>,
pub(crate) latest_sample_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) latest_inference: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) model_metrics: std::option::Option<std::vec::Vec<crate::model::EdgeMetric>>,
}
impl Builder {
pub fn model_name(mut self, input: impl Into<std::string::String>) -> Self {
self.model_name = Some(input.into());
self
}
pub fn set_model_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.model_name = input;
self
}
pub fn model_version(mut self, input: impl Into<std::string::String>) -> Self {
self.model_version = Some(input.into());
self
}
pub fn set_model_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.model_version = input;
self
}
pub fn latest_sample_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.latest_sample_time = Some(input);
self
}
pub fn set_latest_sample_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.latest_sample_time = input;
self
}
pub fn latest_inference(mut self, input: aws_smithy_types::DateTime) -> Self {
self.latest_inference = Some(input);
self
}
pub fn set_latest_inference(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.latest_inference = input;
self
}
pub fn model_metrics(mut self, input: crate::model::EdgeMetric) -> Self {
let mut v = self.model_metrics.unwrap_or_default();
v.push(input);
self.model_metrics = Some(v);
self
}
pub fn set_model_metrics(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::EdgeMetric>>,
) -> Self {
self.model_metrics = input;
self
}
pub fn build(self) -> crate::model::Model {
crate::model::Model {
model_name: self.model_name,
model_version: self.model_version,
latest_sample_time: self.latest_sample_time,
latest_inference: self.latest_inference,
model_metrics: self.model_metrics,
}
}
}
}
impl Model {
pub fn builder() -> crate::model::model::Builder {
crate::model::model::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct EdgeMetric {
#[doc(hidden)]
pub dimension: std::option::Option<std::string::String>,
#[doc(hidden)]
pub metric_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub value: f64,
#[doc(hidden)]
pub timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl EdgeMetric {
pub fn dimension(&self) -> std::option::Option<&str> {
self.dimension.as_deref()
}
pub fn metric_name(&self) -> std::option::Option<&str> {
self.metric_name.as_deref()
}
pub fn value(&self) -> f64 {
self.value
}
pub fn timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.timestamp.as_ref()
}
}
pub mod edge_metric {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dimension: std::option::Option<std::string::String>,
pub(crate) metric_name: std::option::Option<std::string::String>,
pub(crate) value: std::option::Option<f64>,
pub(crate) timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
pub fn dimension(mut self, input: impl Into<std::string::String>) -> Self {
self.dimension = Some(input.into());
self
}
pub fn set_dimension(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dimension = input;
self
}
pub fn metric_name(mut self, input: impl Into<std::string::String>) -> Self {
self.metric_name = Some(input.into());
self
}
pub fn set_metric_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.metric_name = input;
self
}
pub fn value(mut self, input: f64) -> Self {
self.value = Some(input);
self
}
pub fn set_value(mut self, input: std::option::Option<f64>) -> Self {
self.value = input;
self
}
pub fn timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.timestamp = Some(input);
self
}
pub fn set_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.timestamp = input;
self
}
pub fn build(self) -> crate::model::EdgeMetric {
crate::model::EdgeMetric {
dimension: self.dimension,
metric_name: self.metric_name,
value: self.value.unwrap_or_default(),
timestamp: self.timestamp,
}
}
}
}
impl EdgeMetric {
pub fn builder() -> crate::model::edge_metric::Builder {
crate::model::edge_metric::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct EdgeDeployment {
#[doc(hidden)]
pub deployment_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub r#type: std::option::Option<crate::model::DeploymentType>,
#[doc(hidden)]
pub failure_handling_policy: std::option::Option<crate::model::FailureHandlingPolicy>,
#[doc(hidden)]
pub definitions: std::option::Option<std::vec::Vec<crate::model::Definition>>,
}
impl EdgeDeployment {
pub fn deployment_name(&self) -> std::option::Option<&str> {
self.deployment_name.as_deref()
}
pub fn r#type(&self) -> std::option::Option<&crate::model::DeploymentType> {
self.r#type.as_ref()
}
pub fn failure_handling_policy(
&self,
) -> std::option::Option<&crate::model::FailureHandlingPolicy> {
self.failure_handling_policy.as_ref()
}
pub fn definitions(&self) -> std::option::Option<&[crate::model::Definition]> {
self.definitions.as_deref()
}
}
pub mod edge_deployment {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) deployment_name: std::option::Option<std::string::String>,
pub(crate) r#type: std::option::Option<crate::model::DeploymentType>,
pub(crate) failure_handling_policy:
std::option::Option<crate::model::FailureHandlingPolicy>,
pub(crate) definitions: std::option::Option<std::vec::Vec<crate::model::Definition>>,
}
impl Builder {
pub fn deployment_name(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_name = Some(input.into());
self
}
pub fn set_deployment_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_name = input;
self
}
pub fn r#type(mut self, input: crate::model::DeploymentType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(
mut self,
input: std::option::Option<crate::model::DeploymentType>,
) -> Self {
self.r#type = input;
self
}
pub fn failure_handling_policy(
mut self,
input: crate::model::FailureHandlingPolicy,
) -> Self {
self.failure_handling_policy = Some(input);
self
}
pub fn set_failure_handling_policy(
mut self,
input: std::option::Option<crate::model::FailureHandlingPolicy>,
) -> Self {
self.failure_handling_policy = input;
self
}
pub fn definitions(mut self, input: crate::model::Definition) -> Self {
let mut v = self.definitions.unwrap_or_default();
v.push(input);
self.definitions = Some(v);
self
}
pub fn set_definitions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Definition>>,
) -> Self {
self.definitions = input;
self
}
pub fn build(self) -> crate::model::EdgeDeployment {
crate::model::EdgeDeployment {
deployment_name: self.deployment_name,
r#type: self.r#type,
failure_handling_policy: self.failure_handling_policy,
definitions: self.definitions,
}
}
}
}
impl EdgeDeployment {
pub fn builder() -> crate::model::edge_deployment::Builder {
crate::model::edge_deployment::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Definition {
#[doc(hidden)]
pub model_handle: std::option::Option<std::string::String>,
#[doc(hidden)]
pub s3_url: std::option::Option<std::string::String>,
#[doc(hidden)]
pub checksum: std::option::Option<crate::model::Checksum>,
#[doc(hidden)]
pub state: std::option::Option<crate::model::ModelState>,
}
impl Definition {
pub fn model_handle(&self) -> std::option::Option<&str> {
self.model_handle.as_deref()
}
pub fn s3_url(&self) -> std::option::Option<&str> {
self.s3_url.as_deref()
}
pub fn checksum(&self) -> std::option::Option<&crate::model::Checksum> {
self.checksum.as_ref()
}
pub fn state(&self) -> std::option::Option<&crate::model::ModelState> {
self.state.as_ref()
}
}
pub mod definition {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) model_handle: std::option::Option<std::string::String>,
pub(crate) s3_url: std::option::Option<std::string::String>,
pub(crate) checksum: std::option::Option<crate::model::Checksum>,
pub(crate) state: std::option::Option<crate::model::ModelState>,
}
impl Builder {
pub fn model_handle(mut self, input: impl Into<std::string::String>) -> Self {
self.model_handle = Some(input.into());
self
}
pub fn set_model_handle(mut self, input: std::option::Option<std::string::String>) -> Self {
self.model_handle = input;
self
}
pub fn s3_url(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_url = Some(input.into());
self
}
pub fn set_s3_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.s3_url = input;
self
}
pub fn checksum(mut self, input: crate::model::Checksum) -> Self {
self.checksum = Some(input);
self
}
pub fn set_checksum(mut self, input: std::option::Option<crate::model::Checksum>) -> Self {
self.checksum = input;
self
}
pub fn state(mut self, input: crate::model::ModelState) -> Self {
self.state = Some(input);
self
}
pub fn set_state(mut self, input: std::option::Option<crate::model::ModelState>) -> Self {
self.state = input;
self
}
pub fn build(self) -> crate::model::Definition {
crate::model::Definition {
model_handle: self.model_handle,
s3_url: self.s3_url,
checksum: self.checksum,
state: self.state,
}
}
}
}
impl Definition {
pub fn builder() -> crate::model::definition::Builder {
crate::model::definition::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Checksum {
#[doc(hidden)]
pub r#type: std::option::Option<crate::model::ChecksumType>,
#[doc(hidden)]
pub sum: std::option::Option<std::string::String>,
}
impl Checksum {
pub fn r#type(&self) -> std::option::Option<&crate::model::ChecksumType> {
self.r#type.as_ref()
}
pub fn sum(&self) -> std::option::Option<&str> {
self.sum.as_deref()
}
}
pub mod checksum {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) r#type: std::option::Option<crate::model::ChecksumType>,
pub(crate) sum: std::option::Option<std::string::String>,
}
impl Builder {
pub fn r#type(mut self, input: crate::model::ChecksumType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(mut self, input: std::option::Option<crate::model::ChecksumType>) -> Self {
self.r#type = input;
self
}
pub fn sum(mut self, input: impl Into<std::string::String>) -> Self {
self.sum = Some(input.into());
self
}
pub fn set_sum(mut self, input: std::option::Option<std::string::String>) -> Self {
self.sum = input;
self
}
pub fn build(self) -> crate::model::Checksum {
crate::model::Checksum {
r#type: self.r#type,
sum: self.sum,
}
}
}
}
impl Checksum {
pub fn builder() -> crate::model::checksum::Builder {
crate::model::checksum::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum ChecksumType {
#[allow(missing_docs)] Sha1,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ChecksumType {
fn from(s: &str) -> Self {
match s {
"SHA1" => ChecksumType::Sha1,
other => ChecksumType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for ChecksumType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ChecksumType::from(s))
}
}
impl ChecksumType {
pub fn as_str(&self) -> &str {
match self {
ChecksumType::Sha1 => "SHA1",
ChecksumType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["SHA1"]
}
}
impl AsRef<str> for ChecksumType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum FailureHandlingPolicy {
#[allow(missing_docs)] DoNothing,
#[allow(missing_docs)] RollbackOnFailure,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for FailureHandlingPolicy {
fn from(s: &str) -> Self {
match s {
"DO_NOTHING" => FailureHandlingPolicy::DoNothing,
"ROLLBACK_ON_FAILURE" => FailureHandlingPolicy::RollbackOnFailure,
other => {
FailureHandlingPolicy::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for FailureHandlingPolicy {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(FailureHandlingPolicy::from(s))
}
}
impl FailureHandlingPolicy {
pub fn as_str(&self) -> &str {
match self {
FailureHandlingPolicy::DoNothing => "DO_NOTHING",
FailureHandlingPolicy::RollbackOnFailure => "ROLLBACK_ON_FAILURE",
FailureHandlingPolicy::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["DO_NOTHING", "ROLLBACK_ON_FAILURE"]
}
}
impl AsRef<str> for FailureHandlingPolicy {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum DeploymentType {
#[allow(missing_docs)] Model,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for DeploymentType {
fn from(s: &str) -> Self {
match s {
"Model" => DeploymentType::Model,
other => DeploymentType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for DeploymentType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(DeploymentType::from(s))
}
}
impl DeploymentType {
pub fn as_str(&self) -> &str {
match self {
DeploymentType::Model => "Model",
DeploymentType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["Model"]
}
}
impl AsRef<str> for DeploymentType {
fn as_ref(&self) -> &str {
self.as_str()
}
}