#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ErrorDetail {
#[doc(hidden)]
pub detailed_error_code: std::option::Option<std::string::String>,
#[doc(hidden)]
pub detailed_error_message: std::option::Option<std::string::String>,
}
impl ErrorDetail {
pub fn detailed_error_code(&self) -> std::option::Option<&str> {
self.detailed_error_code.as_deref()
}
pub fn detailed_error_message(&self) -> std::option::Option<&str> {
self.detailed_error_message.as_deref()
}
}
pub mod error_detail {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) detailed_error_code: std::option::Option<std::string::String>,
pub(crate) detailed_error_message: std::option::Option<std::string::String>,
}
impl Builder {
pub fn detailed_error_code(mut self, input: impl Into<std::string::String>) -> Self {
self.detailed_error_code = Some(input.into());
self
}
pub fn set_detailed_error_code(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.detailed_error_code = input;
self
}
pub fn detailed_error_message(mut self, input: impl Into<std::string::String>) -> Self {
self.detailed_error_message = Some(input.into());
self
}
pub fn set_detailed_error_message(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.detailed_error_message = input;
self
}
pub fn build(self) -> crate::model::ErrorDetail {
crate::model::ErrorDetail {
detailed_error_code: self.detailed_error_code,
detailed_error_message: self.detailed_error_message,
}
}
}
}
impl ErrorDetail {
pub fn builder() -> crate::model::error_detail::Builder {
crate::model::error_detail::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TelemetryConfigurationUpdate {
#[doc(hidden)]
pub telemetry: std::option::Option<crate::model::Telemetry>,
}
impl TelemetryConfigurationUpdate {
pub fn telemetry(&self) -> std::option::Option<&crate::model::Telemetry> {
self.telemetry.as_ref()
}
}
pub mod telemetry_configuration_update {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) telemetry: std::option::Option<crate::model::Telemetry>,
}
impl Builder {
pub fn telemetry(mut self, input: crate::model::Telemetry) -> Self {
self.telemetry = Some(input);
self
}
pub fn set_telemetry(
mut self,
input: std::option::Option<crate::model::Telemetry>,
) -> Self {
self.telemetry = input;
self
}
pub fn build(self) -> crate::model::TelemetryConfigurationUpdate {
crate::model::TelemetryConfigurationUpdate {
telemetry: self.telemetry,
}
}
}
}
impl TelemetryConfigurationUpdate {
pub fn builder() -> crate::model::telemetry_configuration_update::Builder {
crate::model::telemetry_configuration_update::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 Telemetry {
#[allow(missing_docs)] Off,
#[allow(missing_docs)] On,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Telemetry {
fn from(s: &str) -> Self {
match s {
"Off" => Telemetry::Off,
"On" => Telemetry::On,
other => Telemetry::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for Telemetry {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(Telemetry::from(s))
}
}
impl Telemetry {
pub fn as_str(&self) -> &str {
match self {
Telemetry::Off => "Off",
Telemetry::On => "On",
Telemetry::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["Off", "On"]
}
}
impl AsRef<str> for Telemetry {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ConnectivityInfo {
#[doc(hidden)]
pub host_address: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub metadata: std::option::Option<std::string::String>,
#[doc(hidden)]
pub port_number: i32,
}
impl ConnectivityInfo {
pub fn host_address(&self) -> std::option::Option<&str> {
self.host_address.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn metadata(&self) -> std::option::Option<&str> {
self.metadata.as_deref()
}
pub fn port_number(&self) -> i32 {
self.port_number
}
}
pub mod connectivity_info {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) host_address: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) metadata: std::option::Option<std::string::String>,
pub(crate) port_number: std::option::Option<i32>,
}
impl Builder {
pub fn host_address(mut self, input: impl Into<std::string::String>) -> Self {
self.host_address = Some(input.into());
self
}
pub fn set_host_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.host_address = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn metadata(mut self, input: impl Into<std::string::String>) -> Self {
self.metadata = Some(input.into());
self
}
pub fn set_metadata(mut self, input: std::option::Option<std::string::String>) -> Self {
self.metadata = input;
self
}
pub fn port_number(mut self, input: i32) -> Self {
self.port_number = Some(input);
self
}
pub fn set_port_number(mut self, input: std::option::Option<i32>) -> Self {
self.port_number = input;
self
}
pub fn build(self) -> crate::model::ConnectivityInfo {
crate::model::ConnectivityInfo {
host_address: self.host_address,
id: self.id,
metadata: self.metadata,
port_number: self.port_number.unwrap_or_default(),
}
}
}
}
impl ConnectivityInfo {
pub fn builder() -> crate::model::connectivity_info::Builder {
crate::model::connectivity_info::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct VersionInformation {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub creation_timestamp: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub version: std::option::Option<std::string::String>,
}
impl VersionInformation {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn creation_timestamp(&self) -> std::option::Option<&str> {
self.creation_timestamp.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn version(&self) -> std::option::Option<&str> {
self.version.as_deref()
}
}
pub mod version_information {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) creation_timestamp: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) version: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
self.creation_timestamp = Some(input.into());
self
}
pub fn set_creation_timestamp(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.creation_timestamp = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
self.version = Some(input.into());
self
}
pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version = input;
self
}
pub fn build(self) -> crate::model::VersionInformation {
crate::model::VersionInformation {
arn: self.arn,
creation_timestamp: self.creation_timestamp,
id: self.id,
version: self.version,
}
}
}
}
impl VersionInformation {
pub fn builder() -> crate::model::version_information::Builder {
crate::model::version_information::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DefinitionInformation {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub creation_timestamp: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub last_updated_timestamp: std::option::Option<std::string::String>,
#[doc(hidden)]
pub latest_version: std::option::Option<std::string::String>,
#[doc(hidden)]
pub latest_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl DefinitionInformation {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn creation_timestamp(&self) -> std::option::Option<&str> {
self.creation_timestamp.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
self.last_updated_timestamp.as_deref()
}
pub fn latest_version(&self) -> std::option::Option<&str> {
self.latest_version.as_deref()
}
pub fn latest_version_arn(&self) -> std::option::Option<&str> {
self.latest_version_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
pub mod definition_information {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) creation_timestamp: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
pub(crate) latest_version: std::option::Option<std::string::String>,
pub(crate) latest_version_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
self.creation_timestamp = Some(input.into());
self
}
pub fn set_creation_timestamp(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.creation_timestamp = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
self.last_updated_timestamp = Some(input.into());
self
}
pub fn set_last_updated_timestamp(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.last_updated_timestamp = input;
self
}
pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
self.latest_version = Some(input.into());
self
}
pub fn set_latest_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.latest_version = input;
self
}
pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.latest_version_arn = Some(input.into());
self
}
pub fn set_latest_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.latest_version_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
pub fn build(self) -> crate::model::DefinitionInformation {
crate::model::DefinitionInformation {
arn: self.arn,
creation_timestamp: self.creation_timestamp,
id: self.id,
last_updated_timestamp: self.last_updated_timestamp,
latest_version: self.latest_version,
latest_version_arn: self.latest_version_arn,
name: self.name,
tags: self.tags,
}
}
}
}
impl DefinitionInformation {
pub fn builder() -> crate::model::definition_information::Builder {
crate::model::definition_information::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GroupInformation {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub creation_timestamp: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub last_updated_timestamp: std::option::Option<std::string::String>,
#[doc(hidden)]
pub latest_version: std::option::Option<std::string::String>,
#[doc(hidden)]
pub latest_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GroupInformation {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn creation_timestamp(&self) -> std::option::Option<&str> {
self.creation_timestamp.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
self.last_updated_timestamp.as_deref()
}
pub fn latest_version(&self) -> std::option::Option<&str> {
self.latest_version.as_deref()
}
pub fn latest_version_arn(&self) -> std::option::Option<&str> {
self.latest_version_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
pub mod group_information {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) creation_timestamp: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
pub(crate) latest_version: std::option::Option<std::string::String>,
pub(crate) latest_version_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
self.creation_timestamp = Some(input.into());
self
}
pub fn set_creation_timestamp(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.creation_timestamp = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
self.last_updated_timestamp = Some(input.into());
self
}
pub fn set_last_updated_timestamp(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.last_updated_timestamp = input;
self
}
pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
self.latest_version = Some(input.into());
self
}
pub fn set_latest_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.latest_version = input;
self
}
pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.latest_version_arn = Some(input.into());
self
}
pub fn set_latest_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.latest_version_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn build(self) -> crate::model::GroupInformation {
crate::model::GroupInformation {
arn: self.arn,
creation_timestamp: self.creation_timestamp,
id: self.id,
last_updated_timestamp: self.last_updated_timestamp,
latest_version: self.latest_version,
latest_version_arn: self.latest_version_arn,
name: self.name,
}
}
}
}
impl GroupInformation {
pub fn builder() -> crate::model::group_information::Builder {
crate::model::group_information::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GroupCertificateAuthorityProperties {
#[doc(hidden)]
pub group_certificate_authority_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub group_certificate_authority_id: std::option::Option<std::string::String>,
}
impl GroupCertificateAuthorityProperties {
pub fn group_certificate_authority_arn(&self) -> std::option::Option<&str> {
self.group_certificate_authority_arn.as_deref()
}
pub fn group_certificate_authority_id(&self) -> std::option::Option<&str> {
self.group_certificate_authority_id.as_deref()
}
}
pub mod group_certificate_authority_properties {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) group_certificate_authority_arn: std::option::Option<std::string::String>,
pub(crate) group_certificate_authority_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn group_certificate_authority_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.group_certificate_authority_arn = Some(input.into());
self
}
pub fn set_group_certificate_authority_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.group_certificate_authority_arn = input;
self
}
pub fn group_certificate_authority_id(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.group_certificate_authority_id = Some(input.into());
self
}
pub fn set_group_certificate_authority_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.group_certificate_authority_id = input;
self
}
pub fn build(self) -> crate::model::GroupCertificateAuthorityProperties {
crate::model::GroupCertificateAuthorityProperties {
group_certificate_authority_arn: self.group_certificate_authority_arn,
group_certificate_authority_id: self.group_certificate_authority_id,
}
}
}
}
impl GroupCertificateAuthorityProperties {
pub fn builder() -> crate::model::group_certificate_authority_properties::Builder {
crate::model::group_certificate_authority_properties::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Deployment {
#[doc(hidden)]
pub created_at: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_type: std::option::Option<crate::model::DeploymentType>,
#[doc(hidden)]
pub group_arn: std::option::Option<std::string::String>,
}
impl Deployment {
pub fn created_at(&self) -> std::option::Option<&str> {
self.created_at.as_deref()
}
pub fn deployment_arn(&self) -> std::option::Option<&str> {
self.deployment_arn.as_deref()
}
pub fn deployment_id(&self) -> std::option::Option<&str> {
self.deployment_id.as_deref()
}
pub fn deployment_type(&self) -> std::option::Option<&crate::model::DeploymentType> {
self.deployment_type.as_ref()
}
pub fn group_arn(&self) -> std::option::Option<&str> {
self.group_arn.as_deref()
}
}
pub mod deployment {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) created_at: std::option::Option<std::string::String>,
pub(crate) deployment_arn: std::option::Option<std::string::String>,
pub(crate) deployment_id: std::option::Option<std::string::String>,
pub(crate) deployment_type: std::option::Option<crate::model::DeploymentType>,
pub(crate) group_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn created_at(mut self, input: impl Into<std::string::String>) -> Self {
self.created_at = Some(input.into());
self
}
pub fn set_created_at(mut self, input: std::option::Option<std::string::String>) -> Self {
self.created_at = input;
self
}
pub fn deployment_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_arn = Some(input.into());
self
}
pub fn set_deployment_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_arn = input;
self
}
pub fn deployment_id(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_id = Some(input.into());
self
}
pub fn set_deployment_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_id = input;
self
}
pub fn deployment_type(mut self, input: crate::model::DeploymentType) -> Self {
self.deployment_type = Some(input);
self
}
pub fn set_deployment_type(
mut self,
input: std::option::Option<crate::model::DeploymentType>,
) -> Self {
self.deployment_type = input;
self
}
pub fn group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.group_arn = Some(input.into());
self
}
pub fn set_group_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_arn = input;
self
}
pub fn build(self) -> crate::model::Deployment {
crate::model::Deployment {
created_at: self.created_at,
deployment_arn: self.deployment_arn,
deployment_id: self.deployment_id,
deployment_type: self.deployment_type,
group_arn: self.group_arn,
}
}
}
}
impl Deployment {
pub fn builder() -> crate::model::deployment::Builder {
crate::model::deployment::Builder::default()
}
}
#[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)] ForceResetDeployment,
#[allow(missing_docs)] NewDeployment,
#[allow(missing_docs)] Redeployment,
#[allow(missing_docs)] ResetDeployment,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for DeploymentType {
fn from(s: &str) -> Self {
match s {
"ForceResetDeployment" => DeploymentType::ForceResetDeployment,
"NewDeployment" => DeploymentType::NewDeployment,
"Redeployment" => DeploymentType::Redeployment,
"ResetDeployment" => DeploymentType::ResetDeployment,
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::ForceResetDeployment => "ForceResetDeployment",
DeploymentType::NewDeployment => "NewDeployment",
DeploymentType::Redeployment => "Redeployment",
DeploymentType::ResetDeployment => "ResetDeployment",
DeploymentType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"ForceResetDeployment",
"NewDeployment",
"Redeployment",
"ResetDeployment",
]
}
}
impl AsRef<str> for DeploymentType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BulkDeployment {
#[doc(hidden)]
pub bulk_deployment_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub bulk_deployment_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub created_at: std::option::Option<std::string::String>,
}
impl BulkDeployment {
pub fn bulk_deployment_arn(&self) -> std::option::Option<&str> {
self.bulk_deployment_arn.as_deref()
}
pub fn bulk_deployment_id(&self) -> std::option::Option<&str> {
self.bulk_deployment_id.as_deref()
}
pub fn created_at(&self) -> std::option::Option<&str> {
self.created_at.as_deref()
}
}
pub mod bulk_deployment {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) bulk_deployment_arn: std::option::Option<std::string::String>,
pub(crate) bulk_deployment_id: std::option::Option<std::string::String>,
pub(crate) created_at: std::option::Option<std::string::String>,
}
impl Builder {
pub fn bulk_deployment_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.bulk_deployment_arn = Some(input.into());
self
}
pub fn set_bulk_deployment_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.bulk_deployment_arn = input;
self
}
pub fn bulk_deployment_id(mut self, input: impl Into<std::string::String>) -> Self {
self.bulk_deployment_id = Some(input.into());
self
}
pub fn set_bulk_deployment_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.bulk_deployment_id = input;
self
}
pub fn created_at(mut self, input: impl Into<std::string::String>) -> Self {
self.created_at = Some(input.into());
self
}
pub fn set_created_at(mut self, input: std::option::Option<std::string::String>) -> Self {
self.created_at = input;
self
}
pub fn build(self) -> crate::model::BulkDeployment {
crate::model::BulkDeployment {
bulk_deployment_arn: self.bulk_deployment_arn,
bulk_deployment_id: self.bulk_deployment_id,
created_at: self.created_at,
}
}
}
}
impl BulkDeployment {
pub fn builder() -> crate::model::bulk_deployment::Builder {
crate::model::bulk_deployment::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BulkDeploymentResult {
#[doc(hidden)]
pub created_at: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_status: std::option::Option<std::string::String>,
#[doc(hidden)]
pub deployment_type: std::option::Option<crate::model::DeploymentType>,
#[doc(hidden)]
pub error_details: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
#[doc(hidden)]
pub error_message: std::option::Option<std::string::String>,
#[doc(hidden)]
pub group_arn: std::option::Option<std::string::String>,
}
impl BulkDeploymentResult {
pub fn created_at(&self) -> std::option::Option<&str> {
self.created_at.as_deref()
}
pub fn deployment_arn(&self) -> std::option::Option<&str> {
self.deployment_arn.as_deref()
}
pub fn deployment_id(&self) -> std::option::Option<&str> {
self.deployment_id.as_deref()
}
pub fn deployment_status(&self) -> std::option::Option<&str> {
self.deployment_status.as_deref()
}
pub fn deployment_type(&self) -> std::option::Option<&crate::model::DeploymentType> {
self.deployment_type.as_ref()
}
pub fn error_details(&self) -> std::option::Option<&[crate::model::ErrorDetail]> {
self.error_details.as_deref()
}
pub fn error_message(&self) -> std::option::Option<&str> {
self.error_message.as_deref()
}
pub fn group_arn(&self) -> std::option::Option<&str> {
self.group_arn.as_deref()
}
}
pub mod bulk_deployment_result {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) created_at: std::option::Option<std::string::String>,
pub(crate) deployment_arn: std::option::Option<std::string::String>,
pub(crate) deployment_id: std::option::Option<std::string::String>,
pub(crate) deployment_status: std::option::Option<std::string::String>,
pub(crate) deployment_type: std::option::Option<crate::model::DeploymentType>,
pub(crate) error_details: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
pub(crate) error_message: std::option::Option<std::string::String>,
pub(crate) group_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn created_at(mut self, input: impl Into<std::string::String>) -> Self {
self.created_at = Some(input.into());
self
}
pub fn set_created_at(mut self, input: std::option::Option<std::string::String>) -> Self {
self.created_at = input;
self
}
pub fn deployment_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_arn = Some(input.into());
self
}
pub fn set_deployment_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_arn = input;
self
}
pub fn deployment_id(mut self, input: impl Into<std::string::String>) -> Self {
self.deployment_id = Some(input.into());
self
}
pub fn set_deployment_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deployment_id = 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_type(mut self, input: crate::model::DeploymentType) -> Self {
self.deployment_type = Some(input);
self
}
pub fn set_deployment_type(
mut self,
input: std::option::Option<crate::model::DeploymentType>,
) -> Self {
self.deployment_type = input;
self
}
pub fn error_details(mut self, input: crate::model::ErrorDetail) -> Self {
let mut v = self.error_details.unwrap_or_default();
v.push(input);
self.error_details = Some(v);
self
}
pub fn set_error_details(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
) -> Self {
self.error_details = input;
self
}
pub fn error_message(mut self, input: impl Into<std::string::String>) -> Self {
self.error_message = Some(input.into());
self
}
pub fn set_error_message(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.error_message = input;
self
}
pub fn group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.group_arn = Some(input.into());
self
}
pub fn set_group_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_arn = input;
self
}
pub fn build(self) -> crate::model::BulkDeploymentResult {
crate::model::BulkDeploymentResult {
created_at: self.created_at,
deployment_arn: self.deployment_arn,
deployment_id: self.deployment_id,
deployment_status: self.deployment_status,
deployment_type: self.deployment_type,
error_details: self.error_details,
error_message: self.error_message,
group_arn: self.group_arn,
}
}
}
}
impl BulkDeploymentResult {
pub fn builder() -> crate::model::bulk_deployment_result::Builder {
crate::model::bulk_deployment_result::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RuntimeConfiguration {
#[doc(hidden)]
pub telemetry_configuration: std::option::Option<crate::model::TelemetryConfiguration>,
}
impl RuntimeConfiguration {
pub fn telemetry_configuration(
&self,
) -> std::option::Option<&crate::model::TelemetryConfiguration> {
self.telemetry_configuration.as_ref()
}
}
pub mod runtime_configuration {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) telemetry_configuration:
std::option::Option<crate::model::TelemetryConfiguration>,
}
impl Builder {
pub fn telemetry_configuration(
mut self,
input: crate::model::TelemetryConfiguration,
) -> Self {
self.telemetry_configuration = Some(input);
self
}
pub fn set_telemetry_configuration(
mut self,
input: std::option::Option<crate::model::TelemetryConfiguration>,
) -> Self {
self.telemetry_configuration = input;
self
}
pub fn build(self) -> crate::model::RuntimeConfiguration {
crate::model::RuntimeConfiguration {
telemetry_configuration: self.telemetry_configuration,
}
}
}
}
impl RuntimeConfiguration {
pub fn builder() -> crate::model::runtime_configuration::Builder {
crate::model::runtime_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TelemetryConfiguration {
#[doc(hidden)]
pub configuration_sync_status: std::option::Option<crate::model::ConfigurationSyncStatus>,
#[doc(hidden)]
pub telemetry: std::option::Option<crate::model::Telemetry>,
}
impl TelemetryConfiguration {
pub fn configuration_sync_status(
&self,
) -> std::option::Option<&crate::model::ConfigurationSyncStatus> {
self.configuration_sync_status.as_ref()
}
pub fn telemetry(&self) -> std::option::Option<&crate::model::Telemetry> {
self.telemetry.as_ref()
}
}
pub mod telemetry_configuration {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) configuration_sync_status:
std::option::Option<crate::model::ConfigurationSyncStatus>,
pub(crate) telemetry: std::option::Option<crate::model::Telemetry>,
}
impl Builder {
pub fn configuration_sync_status(
mut self,
input: crate::model::ConfigurationSyncStatus,
) -> Self {
self.configuration_sync_status = Some(input);
self
}
pub fn set_configuration_sync_status(
mut self,
input: std::option::Option<crate::model::ConfigurationSyncStatus>,
) -> Self {
self.configuration_sync_status = input;
self
}
pub fn telemetry(mut self, input: crate::model::Telemetry) -> Self {
self.telemetry = Some(input);
self
}
pub fn set_telemetry(
mut self,
input: std::option::Option<crate::model::Telemetry>,
) -> Self {
self.telemetry = input;
self
}
pub fn build(self) -> crate::model::TelemetryConfiguration {
crate::model::TelemetryConfiguration {
configuration_sync_status: self.configuration_sync_status,
telemetry: self.telemetry,
}
}
}
}
impl TelemetryConfiguration {
pub fn builder() -> crate::model::telemetry_configuration::Builder {
crate::model::telemetry_configuration::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 ConfigurationSyncStatus {
#[allow(missing_docs)] InSync,
#[allow(missing_docs)] OutOfSync,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ConfigurationSyncStatus {
fn from(s: &str) -> Self {
match s {
"InSync" => ConfigurationSyncStatus::InSync,
"OutOfSync" => ConfigurationSyncStatus::OutOfSync,
other => ConfigurationSyncStatus::Unknown(crate::types::UnknownVariantValue(
other.to_owned(),
)),
}
}
}
impl std::str::FromStr for ConfigurationSyncStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ConfigurationSyncStatus::from(s))
}
}
impl ConfigurationSyncStatus {
pub fn as_str(&self) -> &str {
match self {
ConfigurationSyncStatus::InSync => "InSync",
ConfigurationSyncStatus::OutOfSync => "OutOfSync",
ConfigurationSyncStatus::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["InSync", "OutOfSync"]
}
}
impl AsRef<str> for ConfigurationSyncStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubscriptionDefinitionVersion {
#[doc(hidden)]
pub subscriptions: std::option::Option<std::vec::Vec<crate::model::Subscription>>,
}
impl SubscriptionDefinitionVersion {
pub fn subscriptions(&self) -> std::option::Option<&[crate::model::Subscription]> {
self.subscriptions.as_deref()
}
}
pub mod subscription_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) subscriptions: std::option::Option<std::vec::Vec<crate::model::Subscription>>,
}
impl Builder {
pub fn subscriptions(mut self, input: crate::model::Subscription) -> Self {
let mut v = self.subscriptions.unwrap_or_default();
v.push(input);
self.subscriptions = Some(v);
self
}
pub fn set_subscriptions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Subscription>>,
) -> Self {
self.subscriptions = input;
self
}
pub fn build(self) -> crate::model::SubscriptionDefinitionVersion {
crate::model::SubscriptionDefinitionVersion {
subscriptions: self.subscriptions,
}
}
}
}
impl SubscriptionDefinitionVersion {
pub fn builder() -> crate::model::subscription_definition_version::Builder {
crate::model::subscription_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Subscription {
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub source: std::option::Option<std::string::String>,
#[doc(hidden)]
pub subject: std::option::Option<std::string::String>,
#[doc(hidden)]
pub target: std::option::Option<std::string::String>,
}
impl Subscription {
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn source(&self) -> std::option::Option<&str> {
self.source.as_deref()
}
pub fn subject(&self) -> std::option::Option<&str> {
self.subject.as_deref()
}
pub fn target(&self) -> std::option::Option<&str> {
self.target.as_deref()
}
}
pub mod subscription {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) source: std::option::Option<std::string::String>,
pub(crate) subject: std::option::Option<std::string::String>,
pub(crate) target: std::option::Option<std::string::String>,
}
impl Builder {
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn source(mut self, input: impl Into<std::string::String>) -> Self {
self.source = Some(input.into());
self
}
pub fn set_source(mut self, input: std::option::Option<std::string::String>) -> Self {
self.source = input;
self
}
pub fn subject(mut self, input: impl Into<std::string::String>) -> Self {
self.subject = Some(input.into());
self
}
pub fn set_subject(mut self, input: std::option::Option<std::string::String>) -> Self {
self.subject = input;
self
}
pub fn target(mut self, input: impl Into<std::string::String>) -> Self {
self.target = Some(input.into());
self
}
pub fn set_target(mut self, input: std::option::Option<std::string::String>) -> Self {
self.target = input;
self
}
pub fn build(self) -> crate::model::Subscription {
crate::model::Subscription {
id: self.id,
source: self.source,
subject: self.subject,
target: self.target,
}
}
}
}
impl Subscription {
pub fn builder() -> crate::model::subscription::Builder {
crate::model::subscription::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceDefinitionVersion {
#[doc(hidden)]
pub resources: std::option::Option<std::vec::Vec<crate::model::Resource>>,
}
impl ResourceDefinitionVersion {
pub fn resources(&self) -> std::option::Option<&[crate::model::Resource]> {
self.resources.as_deref()
}
}
pub mod resource_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resources: std::option::Option<std::vec::Vec<crate::model::Resource>>,
}
impl Builder {
pub fn resources(mut self, input: crate::model::Resource) -> Self {
let mut v = self.resources.unwrap_or_default();
v.push(input);
self.resources = Some(v);
self
}
pub fn set_resources(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Resource>>,
) -> Self {
self.resources = input;
self
}
pub fn build(self) -> crate::model::ResourceDefinitionVersion {
crate::model::ResourceDefinitionVersion {
resources: self.resources,
}
}
}
}
impl ResourceDefinitionVersion {
pub fn builder() -> crate::model::resource_definition_version::Builder {
crate::model::resource_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Resource {
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub resource_data_container: std::option::Option<crate::model::ResourceDataContainer>,
}
impl Resource {
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn resource_data_container(
&self,
) -> std::option::Option<&crate::model::ResourceDataContainer> {
self.resource_data_container.as_ref()
}
}
pub mod resource {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) resource_data_container:
std::option::Option<crate::model::ResourceDataContainer>,
}
impl Builder {
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn resource_data_container(
mut self,
input: crate::model::ResourceDataContainer,
) -> Self {
self.resource_data_container = Some(input);
self
}
pub fn set_resource_data_container(
mut self,
input: std::option::Option<crate::model::ResourceDataContainer>,
) -> Self {
self.resource_data_container = input;
self
}
pub fn build(self) -> crate::model::Resource {
crate::model::Resource {
id: self.id,
name: self.name,
resource_data_container: self.resource_data_container,
}
}
}
}
impl Resource {
pub fn builder() -> crate::model::resource::Builder {
crate::model::resource::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceDataContainer {
#[doc(hidden)]
pub local_device_resource_data: std::option::Option<crate::model::LocalDeviceResourceData>,
#[doc(hidden)]
pub local_volume_resource_data: std::option::Option<crate::model::LocalVolumeResourceData>,
#[doc(hidden)]
pub s3_machine_learning_model_resource_data:
std::option::Option<crate::model::S3MachineLearningModelResourceData>,
#[doc(hidden)]
pub sage_maker_machine_learning_model_resource_data:
std::option::Option<crate::model::SageMakerMachineLearningModelResourceData>,
#[doc(hidden)]
pub secrets_manager_secret_resource_data:
std::option::Option<crate::model::SecretsManagerSecretResourceData>,
}
impl ResourceDataContainer {
pub fn local_device_resource_data(
&self,
) -> std::option::Option<&crate::model::LocalDeviceResourceData> {
self.local_device_resource_data.as_ref()
}
pub fn local_volume_resource_data(
&self,
) -> std::option::Option<&crate::model::LocalVolumeResourceData> {
self.local_volume_resource_data.as_ref()
}
pub fn s3_machine_learning_model_resource_data(
&self,
) -> std::option::Option<&crate::model::S3MachineLearningModelResourceData> {
self.s3_machine_learning_model_resource_data.as_ref()
}
pub fn sage_maker_machine_learning_model_resource_data(
&self,
) -> std::option::Option<&crate::model::SageMakerMachineLearningModelResourceData> {
self.sage_maker_machine_learning_model_resource_data
.as_ref()
}
pub fn secrets_manager_secret_resource_data(
&self,
) -> std::option::Option<&crate::model::SecretsManagerSecretResourceData> {
self.secrets_manager_secret_resource_data.as_ref()
}
}
pub mod resource_data_container {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) local_device_resource_data:
std::option::Option<crate::model::LocalDeviceResourceData>,
pub(crate) local_volume_resource_data:
std::option::Option<crate::model::LocalVolumeResourceData>,
pub(crate) s3_machine_learning_model_resource_data:
std::option::Option<crate::model::S3MachineLearningModelResourceData>,
pub(crate) sage_maker_machine_learning_model_resource_data:
std::option::Option<crate::model::SageMakerMachineLearningModelResourceData>,
pub(crate) secrets_manager_secret_resource_data:
std::option::Option<crate::model::SecretsManagerSecretResourceData>,
}
impl Builder {
pub fn local_device_resource_data(
mut self,
input: crate::model::LocalDeviceResourceData,
) -> Self {
self.local_device_resource_data = Some(input);
self
}
pub fn set_local_device_resource_data(
mut self,
input: std::option::Option<crate::model::LocalDeviceResourceData>,
) -> Self {
self.local_device_resource_data = input;
self
}
pub fn local_volume_resource_data(
mut self,
input: crate::model::LocalVolumeResourceData,
) -> Self {
self.local_volume_resource_data = Some(input);
self
}
pub fn set_local_volume_resource_data(
mut self,
input: std::option::Option<crate::model::LocalVolumeResourceData>,
) -> Self {
self.local_volume_resource_data = input;
self
}
pub fn s3_machine_learning_model_resource_data(
mut self,
input: crate::model::S3MachineLearningModelResourceData,
) -> Self {
self.s3_machine_learning_model_resource_data = Some(input);
self
}
pub fn set_s3_machine_learning_model_resource_data(
mut self,
input: std::option::Option<crate::model::S3MachineLearningModelResourceData>,
) -> Self {
self.s3_machine_learning_model_resource_data = input;
self
}
pub fn sage_maker_machine_learning_model_resource_data(
mut self,
input: crate::model::SageMakerMachineLearningModelResourceData,
) -> Self {
self.sage_maker_machine_learning_model_resource_data = Some(input);
self
}
pub fn set_sage_maker_machine_learning_model_resource_data(
mut self,
input: std::option::Option<crate::model::SageMakerMachineLearningModelResourceData>,
) -> Self {
self.sage_maker_machine_learning_model_resource_data = input;
self
}
pub fn secrets_manager_secret_resource_data(
mut self,
input: crate::model::SecretsManagerSecretResourceData,
) -> Self {
self.secrets_manager_secret_resource_data = Some(input);
self
}
pub fn set_secrets_manager_secret_resource_data(
mut self,
input: std::option::Option<crate::model::SecretsManagerSecretResourceData>,
) -> Self {
self.secrets_manager_secret_resource_data = input;
self
}
pub fn build(self) -> crate::model::ResourceDataContainer {
crate::model::ResourceDataContainer {
local_device_resource_data: self.local_device_resource_data,
local_volume_resource_data: self.local_volume_resource_data,
s3_machine_learning_model_resource_data: self
.s3_machine_learning_model_resource_data,
sage_maker_machine_learning_model_resource_data: self
.sage_maker_machine_learning_model_resource_data,
secrets_manager_secret_resource_data: self.secrets_manager_secret_resource_data,
}
}
}
}
impl ResourceDataContainer {
pub fn builder() -> crate::model::resource_data_container::Builder {
crate::model::resource_data_container::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SecretsManagerSecretResourceData {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub additional_staging_labels_to_download:
std::option::Option<std::vec::Vec<std::string::String>>,
}
impl SecretsManagerSecretResourceData {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn additional_staging_labels_to_download(
&self,
) -> std::option::Option<&[std::string::String]> {
self.additional_staging_labels_to_download.as_deref()
}
}
pub mod secrets_manager_secret_resource_data {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) additional_staging_labels_to_download:
std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn additional_staging_labels_to_download(
mut self,
input: impl Into<std::string::String>,
) -> Self {
let mut v = self
.additional_staging_labels_to_download
.unwrap_or_default();
v.push(input.into());
self.additional_staging_labels_to_download = Some(v);
self
}
pub fn set_additional_staging_labels_to_download(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.additional_staging_labels_to_download = input;
self
}
pub fn build(self) -> crate::model::SecretsManagerSecretResourceData {
crate::model::SecretsManagerSecretResourceData {
arn: self.arn,
additional_staging_labels_to_download: self.additional_staging_labels_to_download,
}
}
}
}
impl SecretsManagerSecretResourceData {
pub fn builder() -> crate::model::secrets_manager_secret_resource_data::Builder {
crate::model::secrets_manager_secret_resource_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SageMakerMachineLearningModelResourceData {
#[doc(hidden)]
pub destination_path: std::option::Option<std::string::String>,
#[doc(hidden)]
pub owner_setting: std::option::Option<crate::model::ResourceDownloadOwnerSetting>,
#[doc(hidden)]
pub sage_maker_job_arn: std::option::Option<std::string::String>,
}
impl SageMakerMachineLearningModelResourceData {
pub fn destination_path(&self) -> std::option::Option<&str> {
self.destination_path.as_deref()
}
pub fn owner_setting(
&self,
) -> std::option::Option<&crate::model::ResourceDownloadOwnerSetting> {
self.owner_setting.as_ref()
}
pub fn sage_maker_job_arn(&self) -> std::option::Option<&str> {
self.sage_maker_job_arn.as_deref()
}
}
pub mod sage_maker_machine_learning_model_resource_data {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) destination_path: std::option::Option<std::string::String>,
pub(crate) owner_setting: std::option::Option<crate::model::ResourceDownloadOwnerSetting>,
pub(crate) sage_maker_job_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn destination_path(mut self, input: impl Into<std::string::String>) -> Self {
self.destination_path = Some(input.into());
self
}
pub fn set_destination_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.destination_path = input;
self
}
pub fn owner_setting(mut self, input: crate::model::ResourceDownloadOwnerSetting) -> Self {
self.owner_setting = Some(input);
self
}
pub fn set_owner_setting(
mut self,
input: std::option::Option<crate::model::ResourceDownloadOwnerSetting>,
) -> Self {
self.owner_setting = input;
self
}
pub fn sage_maker_job_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.sage_maker_job_arn = Some(input.into());
self
}
pub fn set_sage_maker_job_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.sage_maker_job_arn = input;
self
}
pub fn build(self) -> crate::model::SageMakerMachineLearningModelResourceData {
crate::model::SageMakerMachineLearningModelResourceData {
destination_path: self.destination_path,
owner_setting: self.owner_setting,
sage_maker_job_arn: self.sage_maker_job_arn,
}
}
}
}
impl SageMakerMachineLearningModelResourceData {
pub fn builder() -> crate::model::sage_maker_machine_learning_model_resource_data::Builder {
crate::model::sage_maker_machine_learning_model_resource_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceDownloadOwnerSetting {
#[doc(hidden)]
pub group_owner: std::option::Option<std::string::String>,
#[doc(hidden)]
pub group_permission: std::option::Option<crate::model::Permission>,
}
impl ResourceDownloadOwnerSetting {
pub fn group_owner(&self) -> std::option::Option<&str> {
self.group_owner.as_deref()
}
pub fn group_permission(&self) -> std::option::Option<&crate::model::Permission> {
self.group_permission.as_ref()
}
}
pub mod resource_download_owner_setting {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) group_owner: std::option::Option<std::string::String>,
pub(crate) group_permission: std::option::Option<crate::model::Permission>,
}
impl Builder {
pub fn group_owner(mut self, input: impl Into<std::string::String>) -> Self {
self.group_owner = Some(input.into());
self
}
pub fn set_group_owner(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_owner = input;
self
}
pub fn group_permission(mut self, input: crate::model::Permission) -> Self {
self.group_permission = Some(input);
self
}
pub fn set_group_permission(
mut self,
input: std::option::Option<crate::model::Permission>,
) -> Self {
self.group_permission = input;
self
}
pub fn build(self) -> crate::model::ResourceDownloadOwnerSetting {
crate::model::ResourceDownloadOwnerSetting {
group_owner: self.group_owner,
group_permission: self.group_permission,
}
}
}
}
impl ResourceDownloadOwnerSetting {
pub fn builder() -> crate::model::resource_download_owner_setting::Builder {
crate::model::resource_download_owner_setting::Builder::default()
}
}
#[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 Permission {
#[allow(missing_docs)] Ro,
#[allow(missing_docs)] Rw,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Permission {
fn from(s: &str) -> Self {
match s {
"ro" => Permission::Ro,
"rw" => Permission::Rw,
other => Permission::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for Permission {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(Permission::from(s))
}
}
impl Permission {
pub fn as_str(&self) -> &str {
match self {
Permission::Ro => "ro",
Permission::Rw => "rw",
Permission::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["ro", "rw"]
}
}
impl AsRef<str> for Permission {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct S3MachineLearningModelResourceData {
#[doc(hidden)]
pub destination_path: std::option::Option<std::string::String>,
#[doc(hidden)]
pub owner_setting: std::option::Option<crate::model::ResourceDownloadOwnerSetting>,
#[doc(hidden)]
pub s3_uri: std::option::Option<std::string::String>,
}
impl S3MachineLearningModelResourceData {
pub fn destination_path(&self) -> std::option::Option<&str> {
self.destination_path.as_deref()
}
pub fn owner_setting(
&self,
) -> std::option::Option<&crate::model::ResourceDownloadOwnerSetting> {
self.owner_setting.as_ref()
}
pub fn s3_uri(&self) -> std::option::Option<&str> {
self.s3_uri.as_deref()
}
}
pub mod s3_machine_learning_model_resource_data {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) destination_path: std::option::Option<std::string::String>,
pub(crate) owner_setting: std::option::Option<crate::model::ResourceDownloadOwnerSetting>,
pub(crate) s3_uri: std::option::Option<std::string::String>,
}
impl Builder {
pub fn destination_path(mut self, input: impl Into<std::string::String>) -> Self {
self.destination_path = Some(input.into());
self
}
pub fn set_destination_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.destination_path = input;
self
}
pub fn owner_setting(mut self, input: crate::model::ResourceDownloadOwnerSetting) -> Self {
self.owner_setting = Some(input);
self
}
pub fn set_owner_setting(
mut self,
input: std::option::Option<crate::model::ResourceDownloadOwnerSetting>,
) -> Self {
self.owner_setting = input;
self
}
pub fn s3_uri(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_uri = Some(input.into());
self
}
pub fn set_s3_uri(mut self, input: std::option::Option<std::string::String>) -> Self {
self.s3_uri = input;
self
}
pub fn build(self) -> crate::model::S3MachineLearningModelResourceData {
crate::model::S3MachineLearningModelResourceData {
destination_path: self.destination_path,
owner_setting: self.owner_setting,
s3_uri: self.s3_uri,
}
}
}
}
impl S3MachineLearningModelResourceData {
pub fn builder() -> crate::model::s3_machine_learning_model_resource_data::Builder {
crate::model::s3_machine_learning_model_resource_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LocalVolumeResourceData {
#[doc(hidden)]
pub destination_path: std::option::Option<std::string::String>,
#[doc(hidden)]
pub group_owner_setting: std::option::Option<crate::model::GroupOwnerSetting>,
#[doc(hidden)]
pub source_path: std::option::Option<std::string::String>,
}
impl LocalVolumeResourceData {
pub fn destination_path(&self) -> std::option::Option<&str> {
self.destination_path.as_deref()
}
pub fn group_owner_setting(&self) -> std::option::Option<&crate::model::GroupOwnerSetting> {
self.group_owner_setting.as_ref()
}
pub fn source_path(&self) -> std::option::Option<&str> {
self.source_path.as_deref()
}
}
pub mod local_volume_resource_data {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) destination_path: std::option::Option<std::string::String>,
pub(crate) group_owner_setting: std::option::Option<crate::model::GroupOwnerSetting>,
pub(crate) source_path: std::option::Option<std::string::String>,
}
impl Builder {
pub fn destination_path(mut self, input: impl Into<std::string::String>) -> Self {
self.destination_path = Some(input.into());
self
}
pub fn set_destination_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.destination_path = input;
self
}
pub fn group_owner_setting(mut self, input: crate::model::GroupOwnerSetting) -> Self {
self.group_owner_setting = Some(input);
self
}
pub fn set_group_owner_setting(
mut self,
input: std::option::Option<crate::model::GroupOwnerSetting>,
) -> Self {
self.group_owner_setting = input;
self
}
pub fn source_path(mut self, input: impl Into<std::string::String>) -> Self {
self.source_path = Some(input.into());
self
}
pub fn set_source_path(mut self, input: std::option::Option<std::string::String>) -> Self {
self.source_path = input;
self
}
pub fn build(self) -> crate::model::LocalVolumeResourceData {
crate::model::LocalVolumeResourceData {
destination_path: self.destination_path,
group_owner_setting: self.group_owner_setting,
source_path: self.source_path,
}
}
}
}
impl LocalVolumeResourceData {
pub fn builder() -> crate::model::local_volume_resource_data::Builder {
crate::model::local_volume_resource_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GroupOwnerSetting {
#[doc(hidden)]
pub auto_add_group_owner: bool,
#[doc(hidden)]
pub group_owner: std::option::Option<std::string::String>,
}
impl GroupOwnerSetting {
pub fn auto_add_group_owner(&self) -> bool {
self.auto_add_group_owner
}
pub fn group_owner(&self) -> std::option::Option<&str> {
self.group_owner.as_deref()
}
}
pub mod group_owner_setting {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) auto_add_group_owner: std::option::Option<bool>,
pub(crate) group_owner: std::option::Option<std::string::String>,
}
impl Builder {
pub fn auto_add_group_owner(mut self, input: bool) -> Self {
self.auto_add_group_owner = Some(input);
self
}
pub fn set_auto_add_group_owner(mut self, input: std::option::Option<bool>) -> Self {
self.auto_add_group_owner = input;
self
}
pub fn group_owner(mut self, input: impl Into<std::string::String>) -> Self {
self.group_owner = Some(input.into());
self
}
pub fn set_group_owner(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_owner = input;
self
}
pub fn build(self) -> crate::model::GroupOwnerSetting {
crate::model::GroupOwnerSetting {
auto_add_group_owner: self.auto_add_group_owner.unwrap_or_default(),
group_owner: self.group_owner,
}
}
}
}
impl GroupOwnerSetting {
pub fn builder() -> crate::model::group_owner_setting::Builder {
crate::model::group_owner_setting::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LocalDeviceResourceData {
#[doc(hidden)]
pub group_owner_setting: std::option::Option<crate::model::GroupOwnerSetting>,
#[doc(hidden)]
pub source_path: std::option::Option<std::string::String>,
}
impl LocalDeviceResourceData {
pub fn group_owner_setting(&self) -> std::option::Option<&crate::model::GroupOwnerSetting> {
self.group_owner_setting.as_ref()
}
pub fn source_path(&self) -> std::option::Option<&str> {
self.source_path.as_deref()
}
}
pub mod local_device_resource_data {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) group_owner_setting: std::option::Option<crate::model::GroupOwnerSetting>,
pub(crate) source_path: std::option::Option<std::string::String>,
}
impl Builder {
pub fn group_owner_setting(mut self, input: crate::model::GroupOwnerSetting) -> Self {
self.group_owner_setting = Some(input);
self
}
pub fn set_group_owner_setting(
mut self,
input: std::option::Option<crate::model::GroupOwnerSetting>,
) -> Self {
self.group_owner_setting = input;
self
}
pub fn source_path(mut self, input: impl Into<std::string::String>) -> Self {
self.source_path = Some(input.into());
self
}
pub fn set_source_path(mut self, input: std::option::Option<std::string::String>) -> Self {
self.source_path = input;
self
}
pub fn build(self) -> crate::model::LocalDeviceResourceData {
crate::model::LocalDeviceResourceData {
group_owner_setting: self.group_owner_setting,
source_path: self.source_path,
}
}
}
}
impl LocalDeviceResourceData {
pub fn builder() -> crate::model::local_device_resource_data::Builder {
crate::model::local_device_resource_data::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LoggerDefinitionVersion {
#[doc(hidden)]
pub loggers: std::option::Option<std::vec::Vec<crate::model::Logger>>,
}
impl LoggerDefinitionVersion {
pub fn loggers(&self) -> std::option::Option<&[crate::model::Logger]> {
self.loggers.as_deref()
}
}
pub mod logger_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) loggers: std::option::Option<std::vec::Vec<crate::model::Logger>>,
}
impl Builder {
pub fn loggers(mut self, input: crate::model::Logger) -> Self {
let mut v = self.loggers.unwrap_or_default();
v.push(input);
self.loggers = Some(v);
self
}
pub fn set_loggers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Logger>>,
) -> Self {
self.loggers = input;
self
}
pub fn build(self) -> crate::model::LoggerDefinitionVersion {
crate::model::LoggerDefinitionVersion {
loggers: self.loggers,
}
}
}
}
impl LoggerDefinitionVersion {
pub fn builder() -> crate::model::logger_definition_version::Builder {
crate::model::logger_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Logger {
#[doc(hidden)]
pub component: std::option::Option<crate::model::LoggerComponent>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub level: std::option::Option<crate::model::LoggerLevel>,
#[doc(hidden)]
pub space: i32,
#[doc(hidden)]
pub r#type: std::option::Option<crate::model::LoggerType>,
}
impl Logger {
pub fn component(&self) -> std::option::Option<&crate::model::LoggerComponent> {
self.component.as_ref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn level(&self) -> std::option::Option<&crate::model::LoggerLevel> {
self.level.as_ref()
}
pub fn space(&self) -> i32 {
self.space
}
pub fn r#type(&self) -> std::option::Option<&crate::model::LoggerType> {
self.r#type.as_ref()
}
}
pub mod logger {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) component: std::option::Option<crate::model::LoggerComponent>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) level: std::option::Option<crate::model::LoggerLevel>,
pub(crate) space: std::option::Option<i32>,
pub(crate) r#type: std::option::Option<crate::model::LoggerType>,
}
impl Builder {
pub fn component(mut self, input: crate::model::LoggerComponent) -> Self {
self.component = Some(input);
self
}
pub fn set_component(
mut self,
input: std::option::Option<crate::model::LoggerComponent>,
) -> Self {
self.component = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn level(mut self, input: crate::model::LoggerLevel) -> Self {
self.level = Some(input);
self
}
pub fn set_level(mut self, input: std::option::Option<crate::model::LoggerLevel>) -> Self {
self.level = input;
self
}
pub fn space(mut self, input: i32) -> Self {
self.space = Some(input);
self
}
pub fn set_space(mut self, input: std::option::Option<i32>) -> Self {
self.space = input;
self
}
pub fn r#type(mut self, input: crate::model::LoggerType) -> Self {
self.r#type = Some(input);
self
}
pub fn set_type(mut self, input: std::option::Option<crate::model::LoggerType>) -> Self {
self.r#type = input;
self
}
pub fn build(self) -> crate::model::Logger {
crate::model::Logger {
component: self.component,
id: self.id,
level: self.level,
space: self.space.unwrap_or_default(),
r#type: self.r#type,
}
}
}
}
impl Logger {
pub fn builder() -> crate::model::logger::Builder {
crate::model::logger::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 LoggerType {
#[allow(missing_docs)] AwsCloudWatch,
#[allow(missing_docs)] FileSystem,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for LoggerType {
fn from(s: &str) -> Self {
match s {
"AWSCloudWatch" => LoggerType::AwsCloudWatch,
"FileSystem" => LoggerType::FileSystem,
other => LoggerType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for LoggerType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(LoggerType::from(s))
}
}
impl LoggerType {
pub fn as_str(&self) -> &str {
match self {
LoggerType::AwsCloudWatch => "AWSCloudWatch",
LoggerType::FileSystem => "FileSystem",
LoggerType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["AWSCloudWatch", "FileSystem"]
}
}
impl AsRef<str> for LoggerType {
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 LoggerLevel {
#[allow(missing_docs)] Debug,
#[allow(missing_docs)] Error,
#[allow(missing_docs)] Fatal,
#[allow(missing_docs)] Info,
#[allow(missing_docs)] Warn,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for LoggerLevel {
fn from(s: &str) -> Self {
match s {
"DEBUG" => LoggerLevel::Debug,
"ERROR" => LoggerLevel::Error,
"FATAL" => LoggerLevel::Fatal,
"INFO" => LoggerLevel::Info,
"WARN" => LoggerLevel::Warn,
other => LoggerLevel::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for LoggerLevel {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(LoggerLevel::from(s))
}
}
impl LoggerLevel {
pub fn as_str(&self) -> &str {
match self {
LoggerLevel::Debug => "DEBUG",
LoggerLevel::Error => "ERROR",
LoggerLevel::Fatal => "FATAL",
LoggerLevel::Info => "INFO",
LoggerLevel::Warn => "WARN",
LoggerLevel::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["DEBUG", "ERROR", "FATAL", "INFO", "WARN"]
}
}
impl AsRef<str> for LoggerLevel {
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 LoggerComponent {
#[allow(missing_docs)] GreengrassSystem,
#[allow(missing_docs)] Lambda,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for LoggerComponent {
fn from(s: &str) -> Self {
match s {
"GreengrassSystem" => LoggerComponent::GreengrassSystem,
"Lambda" => LoggerComponent::Lambda,
other => LoggerComponent::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for LoggerComponent {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(LoggerComponent::from(s))
}
}
impl LoggerComponent {
pub fn as_str(&self) -> &str {
match self {
LoggerComponent::GreengrassSystem => "GreengrassSystem",
LoggerComponent::Lambda => "Lambda",
LoggerComponent::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["GreengrassSystem", "Lambda"]
}
}
impl AsRef<str> for LoggerComponent {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GroupVersion {
#[doc(hidden)]
pub connector_definition_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub core_definition_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub device_definition_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub function_definition_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub logger_definition_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub resource_definition_version_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub subscription_definition_version_arn: std::option::Option<std::string::String>,
}
impl GroupVersion {
pub fn connector_definition_version_arn(&self) -> std::option::Option<&str> {
self.connector_definition_version_arn.as_deref()
}
pub fn core_definition_version_arn(&self) -> std::option::Option<&str> {
self.core_definition_version_arn.as_deref()
}
pub fn device_definition_version_arn(&self) -> std::option::Option<&str> {
self.device_definition_version_arn.as_deref()
}
pub fn function_definition_version_arn(&self) -> std::option::Option<&str> {
self.function_definition_version_arn.as_deref()
}
pub fn logger_definition_version_arn(&self) -> std::option::Option<&str> {
self.logger_definition_version_arn.as_deref()
}
pub fn resource_definition_version_arn(&self) -> std::option::Option<&str> {
self.resource_definition_version_arn.as_deref()
}
pub fn subscription_definition_version_arn(&self) -> std::option::Option<&str> {
self.subscription_definition_version_arn.as_deref()
}
}
pub mod group_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connector_definition_version_arn: std::option::Option<std::string::String>,
pub(crate) core_definition_version_arn: std::option::Option<std::string::String>,
pub(crate) device_definition_version_arn: std::option::Option<std::string::String>,
pub(crate) function_definition_version_arn: std::option::Option<std::string::String>,
pub(crate) logger_definition_version_arn: std::option::Option<std::string::String>,
pub(crate) resource_definition_version_arn: std::option::Option<std::string::String>,
pub(crate) subscription_definition_version_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn connector_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.connector_definition_version_arn = Some(input.into());
self
}
pub fn set_connector_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.connector_definition_version_arn = input;
self
}
pub fn core_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.core_definition_version_arn = Some(input.into());
self
}
pub fn set_core_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.core_definition_version_arn = input;
self
}
pub fn device_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.device_definition_version_arn = Some(input.into());
self
}
pub fn set_device_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.device_definition_version_arn = input;
self
}
pub fn function_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.function_definition_version_arn = Some(input.into());
self
}
pub fn set_function_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.function_definition_version_arn = input;
self
}
pub fn logger_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.logger_definition_version_arn = Some(input.into());
self
}
pub fn set_logger_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.logger_definition_version_arn = input;
self
}
pub fn resource_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.resource_definition_version_arn = Some(input.into());
self
}
pub fn set_resource_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.resource_definition_version_arn = input;
self
}
pub fn subscription_definition_version_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.subscription_definition_version_arn = Some(input.into());
self
}
pub fn set_subscription_definition_version_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.subscription_definition_version_arn = input;
self
}
pub fn build(self) -> crate::model::GroupVersion {
crate::model::GroupVersion {
connector_definition_version_arn: self.connector_definition_version_arn,
core_definition_version_arn: self.core_definition_version_arn,
device_definition_version_arn: self.device_definition_version_arn,
function_definition_version_arn: self.function_definition_version_arn,
logger_definition_version_arn: self.logger_definition_version_arn,
resource_definition_version_arn: self.resource_definition_version_arn,
subscription_definition_version_arn: self.subscription_definition_version_arn,
}
}
}
}
impl GroupVersion {
pub fn builder() -> crate::model::group_version::Builder {
crate::model::group_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionDefinitionVersion {
#[doc(hidden)]
pub default_config: std::option::Option<crate::model::FunctionDefaultConfig>,
#[doc(hidden)]
pub functions: std::option::Option<std::vec::Vec<crate::model::Function>>,
}
impl FunctionDefinitionVersion {
pub fn default_config(&self) -> std::option::Option<&crate::model::FunctionDefaultConfig> {
self.default_config.as_ref()
}
pub fn functions(&self) -> std::option::Option<&[crate::model::Function]> {
self.functions.as_deref()
}
}
pub mod function_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) default_config: std::option::Option<crate::model::FunctionDefaultConfig>,
pub(crate) functions: std::option::Option<std::vec::Vec<crate::model::Function>>,
}
impl Builder {
pub fn default_config(mut self, input: crate::model::FunctionDefaultConfig) -> Self {
self.default_config = Some(input);
self
}
pub fn set_default_config(
mut self,
input: std::option::Option<crate::model::FunctionDefaultConfig>,
) -> Self {
self.default_config = input;
self
}
pub fn functions(mut self, input: crate::model::Function) -> Self {
let mut v = self.functions.unwrap_or_default();
v.push(input);
self.functions = Some(v);
self
}
pub fn set_functions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Function>>,
) -> Self {
self.functions = input;
self
}
pub fn build(self) -> crate::model::FunctionDefinitionVersion {
crate::model::FunctionDefinitionVersion {
default_config: self.default_config,
functions: self.functions,
}
}
}
}
impl FunctionDefinitionVersion {
pub fn builder() -> crate::model::function_definition_version::Builder {
crate::model::function_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Function {
#[doc(hidden)]
pub function_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
}
impl Function {
pub fn function_arn(&self) -> std::option::Option<&str> {
self.function_arn.as_deref()
}
pub fn function_configuration(
&self,
) -> std::option::Option<&crate::model::FunctionConfiguration> {
self.function_configuration.as_ref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
}
pub mod function {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) function_arn: std::option::Option<std::string::String>,
pub(crate) function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
pub(crate) id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn function_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.function_arn = Some(input.into());
self
}
pub fn set_function_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.function_arn = input;
self
}
pub fn function_configuration(
mut self,
input: crate::model::FunctionConfiguration,
) -> Self {
self.function_configuration = Some(input);
self
}
pub fn set_function_configuration(
mut self,
input: std::option::Option<crate::model::FunctionConfiguration>,
) -> Self {
self.function_configuration = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn build(self) -> crate::model::Function {
crate::model::Function {
function_arn: self.function_arn,
function_configuration: self.function_configuration,
id: self.id,
}
}
}
}
impl Function {
pub fn builder() -> crate::model::function::Builder {
crate::model::function::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionConfiguration {
#[doc(hidden)]
pub encoding_type: std::option::Option<crate::model::EncodingType>,
#[doc(hidden)]
pub environment: std::option::Option<crate::model::FunctionConfigurationEnvironment>,
#[doc(hidden)]
pub exec_args: std::option::Option<std::string::String>,
#[doc(hidden)]
pub executable: std::option::Option<std::string::String>,
#[doc(hidden)]
pub memory_size: i32,
#[doc(hidden)]
pub pinned: bool,
#[doc(hidden)]
pub timeout: i32,
#[doc(hidden)]
pub function_runtime_override: std::option::Option<std::string::String>,
}
impl FunctionConfiguration {
pub fn encoding_type(&self) -> std::option::Option<&crate::model::EncodingType> {
self.encoding_type.as_ref()
}
pub fn environment(
&self,
) -> std::option::Option<&crate::model::FunctionConfigurationEnvironment> {
self.environment.as_ref()
}
pub fn exec_args(&self) -> std::option::Option<&str> {
self.exec_args.as_deref()
}
pub fn executable(&self) -> std::option::Option<&str> {
self.executable.as_deref()
}
pub fn memory_size(&self) -> i32 {
self.memory_size
}
pub fn pinned(&self) -> bool {
self.pinned
}
pub fn timeout(&self) -> i32 {
self.timeout
}
pub fn function_runtime_override(&self) -> std::option::Option<&str> {
self.function_runtime_override.as_deref()
}
}
pub mod function_configuration {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) encoding_type: std::option::Option<crate::model::EncodingType>,
pub(crate) environment: std::option::Option<crate::model::FunctionConfigurationEnvironment>,
pub(crate) exec_args: std::option::Option<std::string::String>,
pub(crate) executable: std::option::Option<std::string::String>,
pub(crate) memory_size: std::option::Option<i32>,
pub(crate) pinned: std::option::Option<bool>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) function_runtime_override: std::option::Option<std::string::String>,
}
impl Builder {
pub fn encoding_type(mut self, input: crate::model::EncodingType) -> Self {
self.encoding_type = Some(input);
self
}
pub fn set_encoding_type(
mut self,
input: std::option::Option<crate::model::EncodingType>,
) -> Self {
self.encoding_type = input;
self
}
pub fn environment(
mut self,
input: crate::model::FunctionConfigurationEnvironment,
) -> Self {
self.environment = Some(input);
self
}
pub fn set_environment(
mut self,
input: std::option::Option<crate::model::FunctionConfigurationEnvironment>,
) -> Self {
self.environment = input;
self
}
pub fn exec_args(mut self, input: impl Into<std::string::String>) -> Self {
self.exec_args = Some(input.into());
self
}
pub fn set_exec_args(mut self, input: std::option::Option<std::string::String>) -> Self {
self.exec_args = input;
self
}
pub fn executable(mut self, input: impl Into<std::string::String>) -> Self {
self.executable = Some(input.into());
self
}
pub fn set_executable(mut self, input: std::option::Option<std::string::String>) -> Self {
self.executable = input;
self
}
pub fn memory_size(mut self, input: i32) -> Self {
self.memory_size = Some(input);
self
}
pub fn set_memory_size(mut self, input: std::option::Option<i32>) -> Self {
self.memory_size = input;
self
}
pub fn pinned(mut self, input: bool) -> Self {
self.pinned = Some(input);
self
}
pub fn set_pinned(mut self, input: std::option::Option<bool>) -> Self {
self.pinned = input;
self
}
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
pub fn function_runtime_override(mut self, input: impl Into<std::string::String>) -> Self {
self.function_runtime_override = Some(input.into());
self
}
pub fn set_function_runtime_override(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.function_runtime_override = input;
self
}
pub fn build(self) -> crate::model::FunctionConfiguration {
crate::model::FunctionConfiguration {
encoding_type: self.encoding_type,
environment: self.environment,
exec_args: self.exec_args,
executable: self.executable,
memory_size: self.memory_size.unwrap_or_default(),
pinned: self.pinned.unwrap_or_default(),
timeout: self.timeout.unwrap_or_default(),
function_runtime_override: self.function_runtime_override,
}
}
}
}
impl FunctionConfiguration {
pub fn builder() -> crate::model::function_configuration::Builder {
crate::model::function_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionConfigurationEnvironment {
#[doc(hidden)]
pub access_sysfs: bool,
#[doc(hidden)]
pub execution: std::option::Option<crate::model::FunctionExecutionConfig>,
#[doc(hidden)]
pub resource_access_policies:
std::option::Option<std::vec::Vec<crate::model::ResourceAccessPolicy>>,
#[doc(hidden)]
pub variables:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl FunctionConfigurationEnvironment {
pub fn access_sysfs(&self) -> bool {
self.access_sysfs
}
pub fn execution(&self) -> std::option::Option<&crate::model::FunctionExecutionConfig> {
self.execution.as_ref()
}
pub fn resource_access_policies(
&self,
) -> std::option::Option<&[crate::model::ResourceAccessPolicy]> {
self.resource_access_policies.as_deref()
}
pub fn variables(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.variables.as_ref()
}
}
pub mod function_configuration_environment {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) access_sysfs: std::option::Option<bool>,
pub(crate) execution: std::option::Option<crate::model::FunctionExecutionConfig>,
pub(crate) resource_access_policies:
std::option::Option<std::vec::Vec<crate::model::ResourceAccessPolicy>>,
pub(crate) variables: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
pub fn access_sysfs(mut self, input: bool) -> Self {
self.access_sysfs = Some(input);
self
}
pub fn set_access_sysfs(mut self, input: std::option::Option<bool>) -> Self {
self.access_sysfs = input;
self
}
pub fn execution(mut self, input: crate::model::FunctionExecutionConfig) -> Self {
self.execution = Some(input);
self
}
pub fn set_execution(
mut self,
input: std::option::Option<crate::model::FunctionExecutionConfig>,
) -> Self {
self.execution = input;
self
}
pub fn resource_access_policies(
mut self,
input: crate::model::ResourceAccessPolicy,
) -> Self {
let mut v = self.resource_access_policies.unwrap_or_default();
v.push(input);
self.resource_access_policies = Some(v);
self
}
pub fn set_resource_access_policies(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ResourceAccessPolicy>>,
) -> Self {
self.resource_access_policies = input;
self
}
pub fn variables(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.variables.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.variables = Some(hash_map);
self
}
pub fn set_variables(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.variables = input;
self
}
pub fn build(self) -> crate::model::FunctionConfigurationEnvironment {
crate::model::FunctionConfigurationEnvironment {
access_sysfs: self.access_sysfs.unwrap_or_default(),
execution: self.execution,
resource_access_policies: self.resource_access_policies,
variables: self.variables,
}
}
}
}
impl FunctionConfigurationEnvironment {
pub fn builder() -> crate::model::function_configuration_environment::Builder {
crate::model::function_configuration_environment::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceAccessPolicy {
#[doc(hidden)]
pub permission: std::option::Option<crate::model::Permission>,
#[doc(hidden)]
pub resource_id: std::option::Option<std::string::String>,
}
impl ResourceAccessPolicy {
pub fn permission(&self) -> std::option::Option<&crate::model::Permission> {
self.permission.as_ref()
}
pub fn resource_id(&self) -> std::option::Option<&str> {
self.resource_id.as_deref()
}
}
pub mod resource_access_policy {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) permission: std::option::Option<crate::model::Permission>,
pub(crate) resource_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn permission(mut self, input: crate::model::Permission) -> Self {
self.permission = Some(input);
self
}
pub fn set_permission(
mut self,
input: std::option::Option<crate::model::Permission>,
) -> Self {
self.permission = input;
self
}
pub fn resource_id(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_id = Some(input.into());
self
}
pub fn set_resource_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_id = input;
self
}
pub fn build(self) -> crate::model::ResourceAccessPolicy {
crate::model::ResourceAccessPolicy {
permission: self.permission,
resource_id: self.resource_id,
}
}
}
}
impl ResourceAccessPolicy {
pub fn builder() -> crate::model::resource_access_policy::Builder {
crate::model::resource_access_policy::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionExecutionConfig {
#[doc(hidden)]
pub isolation_mode: std::option::Option<crate::model::FunctionIsolationMode>,
#[doc(hidden)]
pub run_as: std::option::Option<crate::model::FunctionRunAsConfig>,
}
impl FunctionExecutionConfig {
pub fn isolation_mode(&self) -> std::option::Option<&crate::model::FunctionIsolationMode> {
self.isolation_mode.as_ref()
}
pub fn run_as(&self) -> std::option::Option<&crate::model::FunctionRunAsConfig> {
self.run_as.as_ref()
}
}
pub mod function_execution_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) isolation_mode: std::option::Option<crate::model::FunctionIsolationMode>,
pub(crate) run_as: std::option::Option<crate::model::FunctionRunAsConfig>,
}
impl Builder {
pub fn isolation_mode(mut self, input: crate::model::FunctionIsolationMode) -> Self {
self.isolation_mode = Some(input);
self
}
pub fn set_isolation_mode(
mut self,
input: std::option::Option<crate::model::FunctionIsolationMode>,
) -> Self {
self.isolation_mode = input;
self
}
pub fn run_as(mut self, input: crate::model::FunctionRunAsConfig) -> Self {
self.run_as = Some(input);
self
}
pub fn set_run_as(
mut self,
input: std::option::Option<crate::model::FunctionRunAsConfig>,
) -> Self {
self.run_as = input;
self
}
pub fn build(self) -> crate::model::FunctionExecutionConfig {
crate::model::FunctionExecutionConfig {
isolation_mode: self.isolation_mode,
run_as: self.run_as,
}
}
}
}
impl FunctionExecutionConfig {
pub fn builder() -> crate::model::function_execution_config::Builder {
crate::model::function_execution_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionRunAsConfig {
#[doc(hidden)]
pub gid: i32,
#[doc(hidden)]
pub uid: i32,
}
impl FunctionRunAsConfig {
pub fn gid(&self) -> i32 {
self.gid
}
pub fn uid(&self) -> i32 {
self.uid
}
}
pub mod function_run_as_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) gid: std::option::Option<i32>,
pub(crate) uid: std::option::Option<i32>,
}
impl Builder {
pub fn gid(mut self, input: i32) -> Self {
self.gid = Some(input);
self
}
pub fn set_gid(mut self, input: std::option::Option<i32>) -> Self {
self.gid = input;
self
}
pub fn uid(mut self, input: i32) -> Self {
self.uid = Some(input);
self
}
pub fn set_uid(mut self, input: std::option::Option<i32>) -> Self {
self.uid = input;
self
}
pub fn build(self) -> crate::model::FunctionRunAsConfig {
crate::model::FunctionRunAsConfig {
gid: self.gid.unwrap_or_default(),
uid: self.uid.unwrap_or_default(),
}
}
}
}
impl FunctionRunAsConfig {
pub fn builder() -> crate::model::function_run_as_config::Builder {
crate::model::function_run_as_config::Builder::default()
}
}
#[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 FunctionIsolationMode {
#[allow(missing_docs)] GreengrassContainer,
#[allow(missing_docs)] NoContainer,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for FunctionIsolationMode {
fn from(s: &str) -> Self {
match s {
"GreengrassContainer" => FunctionIsolationMode::GreengrassContainer,
"NoContainer" => FunctionIsolationMode::NoContainer,
other => {
FunctionIsolationMode::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for FunctionIsolationMode {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(FunctionIsolationMode::from(s))
}
}
impl FunctionIsolationMode {
pub fn as_str(&self) -> &str {
match self {
FunctionIsolationMode::GreengrassContainer => "GreengrassContainer",
FunctionIsolationMode::NoContainer => "NoContainer",
FunctionIsolationMode::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["GreengrassContainer", "NoContainer"]
}
}
impl AsRef<str> for FunctionIsolationMode {
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 EncodingType {
#[allow(missing_docs)] Binary,
#[allow(missing_docs)] Json,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for EncodingType {
fn from(s: &str) -> Self {
match s {
"binary" => EncodingType::Binary,
"json" => EncodingType::Json,
other => EncodingType::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for EncodingType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(EncodingType::from(s))
}
}
impl EncodingType {
pub fn as_str(&self) -> &str {
match self {
EncodingType::Binary => "binary",
EncodingType::Json => "json",
EncodingType::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["binary", "json"]
}
}
impl AsRef<str> for EncodingType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionDefaultConfig {
#[doc(hidden)]
pub execution: std::option::Option<crate::model::FunctionDefaultExecutionConfig>,
}
impl FunctionDefaultConfig {
pub fn execution(&self) -> std::option::Option<&crate::model::FunctionDefaultExecutionConfig> {
self.execution.as_ref()
}
}
pub mod function_default_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) execution: std::option::Option<crate::model::FunctionDefaultExecutionConfig>,
}
impl Builder {
pub fn execution(mut self, input: crate::model::FunctionDefaultExecutionConfig) -> Self {
self.execution = Some(input);
self
}
pub fn set_execution(
mut self,
input: std::option::Option<crate::model::FunctionDefaultExecutionConfig>,
) -> Self {
self.execution = input;
self
}
pub fn build(self) -> crate::model::FunctionDefaultConfig {
crate::model::FunctionDefaultConfig {
execution: self.execution,
}
}
}
}
impl FunctionDefaultConfig {
pub fn builder() -> crate::model::function_default_config::Builder {
crate::model::function_default_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FunctionDefaultExecutionConfig {
#[doc(hidden)]
pub isolation_mode: std::option::Option<crate::model::FunctionIsolationMode>,
#[doc(hidden)]
pub run_as: std::option::Option<crate::model::FunctionRunAsConfig>,
}
impl FunctionDefaultExecutionConfig {
pub fn isolation_mode(&self) -> std::option::Option<&crate::model::FunctionIsolationMode> {
self.isolation_mode.as_ref()
}
pub fn run_as(&self) -> std::option::Option<&crate::model::FunctionRunAsConfig> {
self.run_as.as_ref()
}
}
pub mod function_default_execution_config {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) isolation_mode: std::option::Option<crate::model::FunctionIsolationMode>,
pub(crate) run_as: std::option::Option<crate::model::FunctionRunAsConfig>,
}
impl Builder {
pub fn isolation_mode(mut self, input: crate::model::FunctionIsolationMode) -> Self {
self.isolation_mode = Some(input);
self
}
pub fn set_isolation_mode(
mut self,
input: std::option::Option<crate::model::FunctionIsolationMode>,
) -> Self {
self.isolation_mode = input;
self
}
pub fn run_as(mut self, input: crate::model::FunctionRunAsConfig) -> Self {
self.run_as = Some(input);
self
}
pub fn set_run_as(
mut self,
input: std::option::Option<crate::model::FunctionRunAsConfig>,
) -> Self {
self.run_as = input;
self
}
pub fn build(self) -> crate::model::FunctionDefaultExecutionConfig {
crate::model::FunctionDefaultExecutionConfig {
isolation_mode: self.isolation_mode,
run_as: self.run_as,
}
}
}
}
impl FunctionDefaultExecutionConfig {
pub fn builder() -> crate::model::function_default_execution_config::Builder {
crate::model::function_default_execution_config::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeviceDefinitionVersion {
#[doc(hidden)]
pub devices: std::option::Option<std::vec::Vec<crate::model::Device>>,
}
impl DeviceDefinitionVersion {
pub fn devices(&self) -> std::option::Option<&[crate::model::Device]> {
self.devices.as_deref()
}
}
pub mod device_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) devices: std::option::Option<std::vec::Vec<crate::model::Device>>,
}
impl Builder {
pub fn devices(mut self, input: crate::model::Device) -> Self {
let mut v = self.devices.unwrap_or_default();
v.push(input);
self.devices = Some(v);
self
}
pub fn set_devices(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Device>>,
) -> Self {
self.devices = input;
self
}
pub fn build(self) -> crate::model::DeviceDefinitionVersion {
crate::model::DeviceDefinitionVersion {
devices: self.devices,
}
}
}
}
impl DeviceDefinitionVersion {
pub fn builder() -> crate::model::device_definition_version::Builder {
crate::model::device_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Device {
#[doc(hidden)]
pub certificate_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub sync_shadow: bool,
#[doc(hidden)]
pub thing_arn: std::option::Option<std::string::String>,
}
impl Device {
pub fn certificate_arn(&self) -> std::option::Option<&str> {
self.certificate_arn.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn sync_shadow(&self) -> bool {
self.sync_shadow
}
pub fn thing_arn(&self) -> std::option::Option<&str> {
self.thing_arn.as_deref()
}
}
pub mod device {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) certificate_arn: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) sync_shadow: std::option::Option<bool>,
pub(crate) thing_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn certificate_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_arn = Some(input.into());
self
}
pub fn set_certificate_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_arn = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn sync_shadow(mut self, input: bool) -> Self {
self.sync_shadow = Some(input);
self
}
pub fn set_sync_shadow(mut self, input: std::option::Option<bool>) -> Self {
self.sync_shadow = input;
self
}
pub fn thing_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.thing_arn = Some(input.into());
self
}
pub fn set_thing_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.thing_arn = input;
self
}
pub fn build(self) -> crate::model::Device {
crate::model::Device {
certificate_arn: self.certificate_arn,
id: self.id,
sync_shadow: self.sync_shadow.unwrap_or_default(),
thing_arn: self.thing_arn,
}
}
}
}
impl Device {
pub fn builder() -> crate::model::device::Builder {
crate::model::device::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CoreDefinitionVersion {
#[doc(hidden)]
pub cores: std::option::Option<std::vec::Vec<crate::model::Core>>,
}
impl CoreDefinitionVersion {
pub fn cores(&self) -> std::option::Option<&[crate::model::Core]> {
self.cores.as_deref()
}
}
pub mod core_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) cores: std::option::Option<std::vec::Vec<crate::model::Core>>,
}
impl Builder {
pub fn cores(mut self, input: crate::model::Core) -> Self {
let mut v = self.cores.unwrap_or_default();
v.push(input);
self.cores = Some(v);
self
}
pub fn set_cores(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Core>>,
) -> Self {
self.cores = input;
self
}
pub fn build(self) -> crate::model::CoreDefinitionVersion {
crate::model::CoreDefinitionVersion { cores: self.cores }
}
}
}
impl CoreDefinitionVersion {
pub fn builder() -> crate::model::core_definition_version::Builder {
crate::model::core_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Core {
#[doc(hidden)]
pub certificate_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub sync_shadow: bool,
#[doc(hidden)]
pub thing_arn: std::option::Option<std::string::String>,
}
impl Core {
pub fn certificate_arn(&self) -> std::option::Option<&str> {
self.certificate_arn.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn sync_shadow(&self) -> bool {
self.sync_shadow
}
pub fn thing_arn(&self) -> std::option::Option<&str> {
self.thing_arn.as_deref()
}
}
pub mod core {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) certificate_arn: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) sync_shadow: std::option::Option<bool>,
pub(crate) thing_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn certificate_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_arn = Some(input.into());
self
}
pub fn set_certificate_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_arn = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn sync_shadow(mut self, input: bool) -> Self {
self.sync_shadow = Some(input);
self
}
pub fn set_sync_shadow(mut self, input: std::option::Option<bool>) -> Self {
self.sync_shadow = input;
self
}
pub fn thing_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.thing_arn = Some(input.into());
self
}
pub fn set_thing_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.thing_arn = input;
self
}
pub fn build(self) -> crate::model::Core {
crate::model::Core {
certificate_arn: self.certificate_arn,
id: self.id,
sync_shadow: self.sync_shadow.unwrap_or_default(),
thing_arn: self.thing_arn,
}
}
}
}
impl Core {
pub fn builder() -> crate::model::core::Builder {
crate::model::core::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ConnectorDefinitionVersion {
#[doc(hidden)]
pub connectors: std::option::Option<std::vec::Vec<crate::model::Connector>>,
}
impl ConnectorDefinitionVersion {
pub fn connectors(&self) -> std::option::Option<&[crate::model::Connector]> {
self.connectors.as_deref()
}
}
pub mod connector_definition_version {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connectors: std::option::Option<std::vec::Vec<crate::model::Connector>>,
}
impl Builder {
pub fn connectors(mut self, input: crate::model::Connector) -> Self {
let mut v = self.connectors.unwrap_or_default();
v.push(input);
self.connectors = Some(v);
self
}
pub fn set_connectors(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Connector>>,
) -> Self {
self.connectors = input;
self
}
pub fn build(self) -> crate::model::ConnectorDefinitionVersion {
crate::model::ConnectorDefinitionVersion {
connectors: self.connectors,
}
}
}
}
impl ConnectorDefinitionVersion {
pub fn builder() -> crate::model::connector_definition_version::Builder {
crate::model::connector_definition_version::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Connector {
#[doc(hidden)]
pub connector_arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub parameters:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl Connector {
pub fn connector_arn(&self) -> std::option::Option<&str> {
self.connector_arn.as_deref()
}
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
pub fn parameters(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.parameters.as_ref()
}
}
pub mod connector {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connector_arn: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) parameters: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
pub fn connector_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.connector_arn = Some(input.into());
self
}
pub fn set_connector_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.connector_arn = input;
self
}
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
pub fn parameters(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.parameters.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.parameters = Some(hash_map);
self
}
pub fn set_parameters(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.parameters = input;
self
}
pub fn build(self) -> crate::model::Connector {
crate::model::Connector {
connector_arn: self.connector_arn,
id: self.id,
parameters: self.parameters,
}
}
}
}
impl Connector {
pub fn builder() -> crate::model::connector::Builder {
crate::model::connector::Builder::default()
}
}
#[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 BulkDeploymentStatus {
#[allow(missing_docs)] Completed,
#[allow(missing_docs)] Failed,
#[allow(missing_docs)] Initializing,
#[allow(missing_docs)] Running,
#[allow(missing_docs)] Stopped,
#[allow(missing_docs)] Stopping,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for BulkDeploymentStatus {
fn from(s: &str) -> Self {
match s {
"Completed" => BulkDeploymentStatus::Completed,
"Failed" => BulkDeploymentStatus::Failed,
"Initializing" => BulkDeploymentStatus::Initializing,
"Running" => BulkDeploymentStatus::Running,
"Stopped" => BulkDeploymentStatus::Stopped,
"Stopping" => BulkDeploymentStatus::Stopping,
other => {
BulkDeploymentStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for BulkDeploymentStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(BulkDeploymentStatus::from(s))
}
}
impl BulkDeploymentStatus {
pub fn as_str(&self) -> &str {
match self {
BulkDeploymentStatus::Completed => "Completed",
BulkDeploymentStatus::Failed => "Failed",
BulkDeploymentStatus::Initializing => "Initializing",
BulkDeploymentStatus::Running => "Running",
BulkDeploymentStatus::Stopped => "Stopped",
BulkDeploymentStatus::Stopping => "Stopping",
BulkDeploymentStatus::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"Completed",
"Failed",
"Initializing",
"Running",
"Stopped",
"Stopping",
]
}
}
impl AsRef<str> for BulkDeploymentStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BulkDeploymentMetrics {
#[doc(hidden)]
pub invalid_input_records: i32,
#[doc(hidden)]
pub records_processed: i32,
#[doc(hidden)]
pub retry_attempts: i32,
}
impl BulkDeploymentMetrics {
pub fn invalid_input_records(&self) -> i32 {
self.invalid_input_records
}
pub fn records_processed(&self) -> i32 {
self.records_processed
}
pub fn retry_attempts(&self) -> i32 {
self.retry_attempts
}
}
pub mod bulk_deployment_metrics {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) invalid_input_records: std::option::Option<i32>,
pub(crate) records_processed: std::option::Option<i32>,
pub(crate) retry_attempts: std::option::Option<i32>,
}
impl Builder {
pub fn invalid_input_records(mut self, input: i32) -> Self {
self.invalid_input_records = Some(input);
self
}
pub fn set_invalid_input_records(mut self, input: std::option::Option<i32>) -> Self {
self.invalid_input_records = input;
self
}
pub fn records_processed(mut self, input: i32) -> Self {
self.records_processed = Some(input);
self
}
pub fn set_records_processed(mut self, input: std::option::Option<i32>) -> Self {
self.records_processed = input;
self
}
pub fn retry_attempts(mut self, input: i32) -> Self {
self.retry_attempts = Some(input);
self
}
pub fn set_retry_attempts(mut self, input: std::option::Option<i32>) -> Self {
self.retry_attempts = input;
self
}
pub fn build(self) -> crate::model::BulkDeploymentMetrics {
crate::model::BulkDeploymentMetrics {
invalid_input_records: self.invalid_input_records.unwrap_or_default(),
records_processed: self.records_processed.unwrap_or_default(),
retry_attempts: self.retry_attempts.unwrap_or_default(),
}
}
}
}
impl BulkDeploymentMetrics {
pub fn builder() -> crate::model::bulk_deployment_metrics::Builder {
crate::model::bulk_deployment_metrics::Builder::default()
}
}
#[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 UpdateTargetsOperatingSystem {
#[allow(missing_docs)] AmazonLinux,
#[allow(missing_docs)] Openwrt,
#[allow(missing_docs)] Raspbian,
#[allow(missing_docs)] Ubuntu,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for UpdateTargetsOperatingSystem {
fn from(s: &str) -> Self {
match s {
"amazon_linux" => UpdateTargetsOperatingSystem::AmazonLinux,
"openwrt" => UpdateTargetsOperatingSystem::Openwrt,
"raspbian" => UpdateTargetsOperatingSystem::Raspbian,
"ubuntu" => UpdateTargetsOperatingSystem::Ubuntu,
other => UpdateTargetsOperatingSystem::Unknown(crate::types::UnknownVariantValue(
other.to_owned(),
)),
}
}
}
impl std::str::FromStr for UpdateTargetsOperatingSystem {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(UpdateTargetsOperatingSystem::from(s))
}
}
impl UpdateTargetsOperatingSystem {
pub fn as_str(&self) -> &str {
match self {
UpdateTargetsOperatingSystem::AmazonLinux => "amazon_linux",
UpdateTargetsOperatingSystem::Openwrt => "openwrt",
UpdateTargetsOperatingSystem::Raspbian => "raspbian",
UpdateTargetsOperatingSystem::Ubuntu => "ubuntu",
UpdateTargetsOperatingSystem::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["amazon_linux", "openwrt", "raspbian", "ubuntu"]
}
}
impl AsRef<str> for UpdateTargetsOperatingSystem {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[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 UpdateTargetsArchitecture {
#[allow(missing_docs)] Aarch64,
#[allow(missing_docs)] Armv6l,
#[allow(missing_docs)] Armv7l,
#[allow(missing_docs)] X8664,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for UpdateTargetsArchitecture {
fn from(s: &str) -> Self {
match s {
"aarch64" => UpdateTargetsArchitecture::Aarch64,
"armv6l" => UpdateTargetsArchitecture::Armv6l,
"armv7l" => UpdateTargetsArchitecture::Armv7l,
"x86_64" => UpdateTargetsArchitecture::X8664,
other => UpdateTargetsArchitecture::Unknown(crate::types::UnknownVariantValue(
other.to_owned(),
)),
}
}
}
impl std::str::FromStr for UpdateTargetsArchitecture {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(UpdateTargetsArchitecture::from(s))
}
}
impl UpdateTargetsArchitecture {
pub fn as_str(&self) -> &str {
match self {
UpdateTargetsArchitecture::Aarch64 => "aarch64",
UpdateTargetsArchitecture::Armv6l => "armv6l",
UpdateTargetsArchitecture::Armv7l => "armv7l",
UpdateTargetsArchitecture::X8664 => "x86_64",
UpdateTargetsArchitecture::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["aarch64", "armv6l", "armv7l", "x86_64"]
}
}
impl AsRef<str> for UpdateTargetsArchitecture {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[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 UpdateAgentLogLevel {
#[allow(missing_docs)] Debug,
#[allow(missing_docs)] Error,
#[allow(missing_docs)] Fatal,
#[allow(missing_docs)] Info,
#[allow(missing_docs)] None,
#[allow(missing_docs)] Trace,
#[allow(missing_docs)] Verbose,
#[allow(missing_docs)] Warn,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for UpdateAgentLogLevel {
fn from(s: &str) -> Self {
match s {
"DEBUG" => UpdateAgentLogLevel::Debug,
"ERROR" => UpdateAgentLogLevel::Error,
"FATAL" => UpdateAgentLogLevel::Fatal,
"INFO" => UpdateAgentLogLevel::Info,
"NONE" => UpdateAgentLogLevel::None,
"TRACE" => UpdateAgentLogLevel::Trace,
"VERBOSE" => UpdateAgentLogLevel::Verbose,
"WARN" => UpdateAgentLogLevel::Warn,
other => {
UpdateAgentLogLevel::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
}
}
}
}
impl std::str::FromStr for UpdateAgentLogLevel {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(UpdateAgentLogLevel::from(s))
}
}
impl UpdateAgentLogLevel {
pub fn as_str(&self) -> &str {
match self {
UpdateAgentLogLevel::Debug => "DEBUG",
UpdateAgentLogLevel::Error => "ERROR",
UpdateAgentLogLevel::Fatal => "FATAL",
UpdateAgentLogLevel::Info => "INFO",
UpdateAgentLogLevel::None => "NONE",
UpdateAgentLogLevel::Trace => "TRACE",
UpdateAgentLogLevel::Verbose => "VERBOSE",
UpdateAgentLogLevel::Warn => "WARN",
UpdateAgentLogLevel::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&[
"DEBUG", "ERROR", "FATAL", "INFO", "NONE", "TRACE", "VERBOSE", "WARN",
]
}
}
impl AsRef<str> for UpdateAgentLogLevel {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[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 SoftwareToUpdate {
#[allow(missing_docs)] Core,
#[allow(missing_docs)] OtaAgent,
Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for SoftwareToUpdate {
fn from(s: &str) -> Self {
match s {
"core" => SoftwareToUpdate::Core,
"ota_agent" => SoftwareToUpdate::OtaAgent,
other => SoftwareToUpdate::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
}
}
}
impl std::str::FromStr for SoftwareToUpdate {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SoftwareToUpdate::from(s))
}
}
impl SoftwareToUpdate {
pub fn as_str(&self) -> &str {
match self {
SoftwareToUpdate::Core => "core",
SoftwareToUpdate::OtaAgent => "ota_agent",
SoftwareToUpdate::Unknown(value) => value.as_str(),
}
}
pub const fn values() -> &'static [&'static str] {
&["core", "ota_agent"]
}
}
impl AsRef<str> for SoftwareToUpdate {
fn as_ref(&self) -> &str {
self.as_str()
}
}