#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SubnetGroup {
pub subnet_group_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub vpc_id: std::option::Option<std::string::String>,
pub subnets: std::option::Option<std::vec::Vec<crate::model::Subnet>>,
}
impl SubnetGroup {
pub fn subnet_group_name(&self) -> std::option::Option<&str> {
self.subnet_group_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn vpc_id(&self) -> std::option::Option<&str> {
self.vpc_id.as_deref()
}
pub fn subnets(&self) -> std::option::Option<&[crate::model::Subnet]> {
self.subnets.as_deref()
}
}
impl std::fmt::Debug for SubnetGroup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SubnetGroup");
formatter.field("subnet_group_name", &self.subnet_group_name);
formatter.field("description", &self.description);
formatter.field("vpc_id", &self.vpc_id);
formatter.field("subnets", &self.subnets);
formatter.finish()
}
}
pub mod subnet_group {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) subnet_group_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) vpc_id: std::option::Option<std::string::String>,
pub(crate) subnets: std::option::Option<std::vec::Vec<crate::model::Subnet>>,
}
impl Builder {
pub fn subnet_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.subnet_group_name = Some(input.into());
self
}
pub fn set_subnet_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.subnet_group_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn vpc_id(mut self, input: impl Into<std::string::String>) -> Self {
self.vpc_id = Some(input.into());
self
}
pub fn set_vpc_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.vpc_id = input;
self
}
pub fn subnets(mut self, input: crate::model::Subnet) -> Self {
let mut v = self.subnets.unwrap_or_default();
v.push(input);
self.subnets = Some(v);
self
}
pub fn set_subnets(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Subnet>>,
) -> Self {
self.subnets = input;
self
}
pub fn build(self) -> crate::model::SubnetGroup {
crate::model::SubnetGroup {
subnet_group_name: self.subnet_group_name,
description: self.description,
vpc_id: self.vpc_id,
subnets: self.subnets,
}
}
}
}
impl SubnetGroup {
pub fn builder() -> crate::model::subnet_group::Builder {
crate::model::subnet_group::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Subnet {
pub subnet_identifier: std::option::Option<std::string::String>,
pub subnet_availability_zone: std::option::Option<std::string::String>,
}
impl Subnet {
pub fn subnet_identifier(&self) -> std::option::Option<&str> {
self.subnet_identifier.as_deref()
}
pub fn subnet_availability_zone(&self) -> std::option::Option<&str> {
self.subnet_availability_zone.as_deref()
}
}
impl std::fmt::Debug for Subnet {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Subnet");
formatter.field("subnet_identifier", &self.subnet_identifier);
formatter.field("subnet_availability_zone", &self.subnet_availability_zone);
formatter.finish()
}
}
pub mod subnet {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) subnet_identifier: std::option::Option<std::string::String>,
pub(crate) subnet_availability_zone: std::option::Option<std::string::String>,
}
impl Builder {
pub fn subnet_identifier(mut self, input: impl Into<std::string::String>) -> Self {
self.subnet_identifier = Some(input.into());
self
}
pub fn set_subnet_identifier(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.subnet_identifier = input;
self
}
pub fn subnet_availability_zone(mut self, input: impl Into<std::string::String>) -> Self {
self.subnet_availability_zone = Some(input.into());
self
}
pub fn set_subnet_availability_zone(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.subnet_availability_zone = input;
self
}
pub fn build(self) -> crate::model::Subnet {
crate::model::Subnet {
subnet_identifier: self.subnet_identifier,
subnet_availability_zone: self.subnet_availability_zone,
}
}
}
}
impl Subnet {
pub fn builder() -> crate::model::subnet::Builder {
crate::model::subnet::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ParameterGroup {
pub parameter_group_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl ParameterGroup {
pub fn parameter_group_name(&self) -> std::option::Option<&str> {
self.parameter_group_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for ParameterGroup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ParameterGroup");
formatter.field("parameter_group_name", &self.parameter_group_name);
formatter.field("description", &self.description);
formatter.finish()
}
}
pub mod parameter_group {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_group_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn parameter_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_group_name = Some(input.into());
self
}
pub fn set_parameter_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_group_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(self) -> crate::model::ParameterGroup {
crate::model::ParameterGroup {
parameter_group_name: self.parameter_group_name,
description: self.description,
}
}
}
}
impl ParameterGroup {
pub fn builder() -> crate::model::parameter_group::Builder {
crate::model::parameter_group::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ParameterNameValue {
pub parameter_name: std::option::Option<std::string::String>,
pub parameter_value: std::option::Option<std::string::String>,
}
impl ParameterNameValue {
pub fn parameter_name(&self) -> std::option::Option<&str> {
self.parameter_name.as_deref()
}
pub fn parameter_value(&self) -> std::option::Option<&str> {
self.parameter_value.as_deref()
}
}
impl std::fmt::Debug for ParameterNameValue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ParameterNameValue");
formatter.field("parameter_name", &self.parameter_name);
formatter.field("parameter_value", &self.parameter_value);
formatter.finish()
}
}
pub mod parameter_name_value {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_name: std::option::Option<std::string::String>,
pub(crate) parameter_value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn parameter_name(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_name = Some(input.into());
self
}
pub fn set_parameter_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_name = input;
self
}
pub fn parameter_value(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_value = Some(input.into());
self
}
pub fn set_parameter_value(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_value = input;
self
}
pub fn build(self) -> crate::model::ParameterNameValue {
crate::model::ParameterNameValue {
parameter_name: self.parameter_name,
parameter_value: self.parameter_value,
}
}
}
}
impl ParameterNameValue {
pub fn builder() -> crate::model::parameter_name_value::Builder {
crate::model::parameter_name_value::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Cluster {
pub cluster_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub cluster_arn: std::option::Option<std::string::String>,
pub total_nodes: std::option::Option<i32>,
pub active_nodes: std::option::Option<i32>,
pub node_type: std::option::Option<std::string::String>,
pub status: std::option::Option<std::string::String>,
pub cluster_discovery_endpoint: std::option::Option<crate::model::Endpoint>,
pub node_ids_to_remove: std::option::Option<std::vec::Vec<std::string::String>>,
pub nodes: std::option::Option<std::vec::Vec<crate::model::Node>>,
pub preferred_maintenance_window: std::option::Option<std::string::String>,
pub notification_configuration: std::option::Option<crate::model::NotificationConfiguration>,
pub subnet_group: std::option::Option<std::string::String>,
pub security_groups: std::option::Option<std::vec::Vec<crate::model::SecurityGroupMembership>>,
pub iam_role_arn: std::option::Option<std::string::String>,
pub parameter_group: std::option::Option<crate::model::ParameterGroupStatus>,
pub sse_description: std::option::Option<crate::model::SseDescription>,
pub cluster_endpoint_encryption_type:
std::option::Option<crate::model::ClusterEndpointEncryptionType>,
}
impl Cluster {
pub fn cluster_name(&self) -> std::option::Option<&str> {
self.cluster_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn cluster_arn(&self) -> std::option::Option<&str> {
self.cluster_arn.as_deref()
}
pub fn total_nodes(&self) -> std::option::Option<i32> {
self.total_nodes
}
pub fn active_nodes(&self) -> std::option::Option<i32> {
self.active_nodes
}
pub fn node_type(&self) -> std::option::Option<&str> {
self.node_type.as_deref()
}
pub fn status(&self) -> std::option::Option<&str> {
self.status.as_deref()
}
pub fn cluster_discovery_endpoint(&self) -> std::option::Option<&crate::model::Endpoint> {
self.cluster_discovery_endpoint.as_ref()
}
pub fn node_ids_to_remove(&self) -> std::option::Option<&[std::string::String]> {
self.node_ids_to_remove.as_deref()
}
pub fn nodes(&self) -> std::option::Option<&[crate::model::Node]> {
self.nodes.as_deref()
}
pub fn preferred_maintenance_window(&self) -> std::option::Option<&str> {
self.preferred_maintenance_window.as_deref()
}
pub fn notification_configuration(
&self,
) -> std::option::Option<&crate::model::NotificationConfiguration> {
self.notification_configuration.as_ref()
}
pub fn subnet_group(&self) -> std::option::Option<&str> {
self.subnet_group.as_deref()
}
pub fn security_groups(&self) -> std::option::Option<&[crate::model::SecurityGroupMembership]> {
self.security_groups.as_deref()
}
pub fn iam_role_arn(&self) -> std::option::Option<&str> {
self.iam_role_arn.as_deref()
}
pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroupStatus> {
self.parameter_group.as_ref()
}
pub fn sse_description(&self) -> std::option::Option<&crate::model::SseDescription> {
self.sse_description.as_ref()
}
pub fn cluster_endpoint_encryption_type(
&self,
) -> std::option::Option<&crate::model::ClusterEndpointEncryptionType> {
self.cluster_endpoint_encryption_type.as_ref()
}
}
impl std::fmt::Debug for Cluster {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Cluster");
formatter.field("cluster_name", &self.cluster_name);
formatter.field("description", &self.description);
formatter.field("cluster_arn", &self.cluster_arn);
formatter.field("total_nodes", &self.total_nodes);
formatter.field("active_nodes", &self.active_nodes);
formatter.field("node_type", &self.node_type);
formatter.field("status", &self.status);
formatter.field(
"cluster_discovery_endpoint",
&self.cluster_discovery_endpoint,
);
formatter.field("node_ids_to_remove", &self.node_ids_to_remove);
formatter.field("nodes", &self.nodes);
formatter.field(
"preferred_maintenance_window",
&self.preferred_maintenance_window,
);
formatter.field(
"notification_configuration",
&self.notification_configuration,
);
formatter.field("subnet_group", &self.subnet_group);
formatter.field("security_groups", &self.security_groups);
formatter.field("iam_role_arn", &self.iam_role_arn);
formatter.field("parameter_group", &self.parameter_group);
formatter.field("sse_description", &self.sse_description);
formatter.field(
"cluster_endpoint_encryption_type",
&self.cluster_endpoint_encryption_type,
);
formatter.finish()
}
}
pub mod cluster {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) cluster_arn: std::option::Option<std::string::String>,
pub(crate) total_nodes: std::option::Option<i32>,
pub(crate) active_nodes: std::option::Option<i32>,
pub(crate) node_type: std::option::Option<std::string::String>,
pub(crate) status: std::option::Option<std::string::String>,
pub(crate) cluster_discovery_endpoint: std::option::Option<crate::model::Endpoint>,
pub(crate) node_ids_to_remove: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) nodes: std::option::Option<std::vec::Vec<crate::model::Node>>,
pub(crate) preferred_maintenance_window: std::option::Option<std::string::String>,
pub(crate) notification_configuration:
std::option::Option<crate::model::NotificationConfiguration>,
pub(crate) subnet_group: std::option::Option<std::string::String>,
pub(crate) security_groups:
std::option::Option<std::vec::Vec<crate::model::SecurityGroupMembership>>,
pub(crate) iam_role_arn: std::option::Option<std::string::String>,
pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroupStatus>,
pub(crate) sse_description: std::option::Option<crate::model::SseDescription>,
pub(crate) cluster_endpoint_encryption_type:
std::option::Option<crate::model::ClusterEndpointEncryptionType>,
}
impl Builder {
pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
self.cluster_name = Some(input.into());
self
}
pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.cluster_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn cluster_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.cluster_arn = Some(input.into());
self
}
pub fn set_cluster_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.cluster_arn = input;
self
}
pub fn total_nodes(mut self, input: i32) -> Self {
self.total_nodes = Some(input);
self
}
pub fn set_total_nodes(mut self, input: std::option::Option<i32>) -> Self {
self.total_nodes = input;
self
}
pub fn active_nodes(mut self, input: i32) -> Self {
self.active_nodes = Some(input);
self
}
pub fn set_active_nodes(mut self, input: std::option::Option<i32>) -> Self {
self.active_nodes = input;
self
}
pub fn node_type(mut self, input: impl Into<std::string::String>) -> Self {
self.node_type = Some(input.into());
self
}
pub fn set_node_type(mut self, input: std::option::Option<std::string::String>) -> Self {
self.node_type = input;
self
}
pub fn status(mut self, input: impl Into<std::string::String>) -> Self {
self.status = Some(input.into());
self
}
pub fn set_status(mut self, input: std::option::Option<std::string::String>) -> Self {
self.status = input;
self
}
pub fn cluster_discovery_endpoint(mut self, input: crate::model::Endpoint) -> Self {
self.cluster_discovery_endpoint = Some(input);
self
}
pub fn set_cluster_discovery_endpoint(
mut self,
input: std::option::Option<crate::model::Endpoint>,
) -> Self {
self.cluster_discovery_endpoint = input;
self
}
pub fn node_ids_to_remove(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.node_ids_to_remove.unwrap_or_default();
v.push(input.into());
self.node_ids_to_remove = Some(v);
self
}
pub fn set_node_ids_to_remove(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.node_ids_to_remove = input;
self
}
pub fn nodes(mut self, input: crate::model::Node) -> Self {
let mut v = self.nodes.unwrap_or_default();
v.push(input);
self.nodes = Some(v);
self
}
pub fn set_nodes(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Node>>,
) -> Self {
self.nodes = input;
self
}
pub fn preferred_maintenance_window(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.preferred_maintenance_window = Some(input.into());
self
}
pub fn set_preferred_maintenance_window(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.preferred_maintenance_window = input;
self
}
pub fn notification_configuration(
mut self,
input: crate::model::NotificationConfiguration,
) -> Self {
self.notification_configuration = Some(input);
self
}
pub fn set_notification_configuration(
mut self,
input: std::option::Option<crate::model::NotificationConfiguration>,
) -> Self {
self.notification_configuration = input;
self
}
pub fn subnet_group(mut self, input: impl Into<std::string::String>) -> Self {
self.subnet_group = Some(input.into());
self
}
pub fn set_subnet_group(mut self, input: std::option::Option<std::string::String>) -> Self {
self.subnet_group = input;
self
}
pub fn security_groups(mut self, input: crate::model::SecurityGroupMembership) -> Self {
let mut v = self.security_groups.unwrap_or_default();
v.push(input);
self.security_groups = Some(v);
self
}
pub fn set_security_groups(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SecurityGroupMembership>>,
) -> Self {
self.security_groups = input;
self
}
pub fn iam_role_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.iam_role_arn = Some(input.into());
self
}
pub fn set_iam_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.iam_role_arn = input;
self
}
pub fn parameter_group(mut self, input: crate::model::ParameterGroupStatus) -> Self {
self.parameter_group = Some(input);
self
}
pub fn set_parameter_group(
mut self,
input: std::option::Option<crate::model::ParameterGroupStatus>,
) -> Self {
self.parameter_group = input;
self
}
pub fn sse_description(mut self, input: crate::model::SseDescription) -> Self {
self.sse_description = Some(input);
self
}
pub fn set_sse_description(
mut self,
input: std::option::Option<crate::model::SseDescription>,
) -> Self {
self.sse_description = input;
self
}
pub fn cluster_endpoint_encryption_type(
mut self,
input: crate::model::ClusterEndpointEncryptionType,
) -> Self {
self.cluster_endpoint_encryption_type = Some(input);
self
}
pub fn set_cluster_endpoint_encryption_type(
mut self,
input: std::option::Option<crate::model::ClusterEndpointEncryptionType>,
) -> Self {
self.cluster_endpoint_encryption_type = input;
self
}
pub fn build(self) -> crate::model::Cluster {
crate::model::Cluster {
cluster_name: self.cluster_name,
description: self.description,
cluster_arn: self.cluster_arn,
total_nodes: self.total_nodes,
active_nodes: self.active_nodes,
node_type: self.node_type,
status: self.status,
cluster_discovery_endpoint: self.cluster_discovery_endpoint,
node_ids_to_remove: self.node_ids_to_remove,
nodes: self.nodes,
preferred_maintenance_window: self.preferred_maintenance_window,
notification_configuration: self.notification_configuration,
subnet_group: self.subnet_group,
security_groups: self.security_groups,
iam_role_arn: self.iam_role_arn,
parameter_group: self.parameter_group,
sse_description: self.sse_description,
cluster_endpoint_encryption_type: self.cluster_endpoint_encryption_type,
}
}
}
}
impl Cluster {
pub fn builder() -> crate::model::cluster::Builder {
crate::model::cluster::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 ClusterEndpointEncryptionType {
#[allow(missing_docs)] None,
#[allow(missing_docs)] Tls,
Unknown(String),
}
impl std::convert::From<&str> for ClusterEndpointEncryptionType {
fn from(s: &str) -> Self {
match s {
"NONE" => ClusterEndpointEncryptionType::None,
"TLS" => ClusterEndpointEncryptionType::Tls,
other => ClusterEndpointEncryptionType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for ClusterEndpointEncryptionType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ClusterEndpointEncryptionType::from(s))
}
}
impl ClusterEndpointEncryptionType {
pub fn as_str(&self) -> &str {
match self {
ClusterEndpointEncryptionType::None => "NONE",
ClusterEndpointEncryptionType::Tls => "TLS",
ClusterEndpointEncryptionType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["NONE", "TLS"]
}
}
impl AsRef<str> for ClusterEndpointEncryptionType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SseDescription {
pub status: std::option::Option<crate::model::SseStatus>,
}
impl SseDescription {
pub fn status(&self) -> std::option::Option<&crate::model::SseStatus> {
self.status.as_ref()
}
}
impl std::fmt::Debug for SseDescription {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SseDescription");
formatter.field("status", &self.status);
formatter.finish()
}
}
pub mod sse_description {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) status: std::option::Option<crate::model::SseStatus>,
}
impl Builder {
pub fn status(mut self, input: crate::model::SseStatus) -> Self {
self.status = Some(input);
self
}
pub fn set_status(mut self, input: std::option::Option<crate::model::SseStatus>) -> Self {
self.status = input;
self
}
pub fn build(self) -> crate::model::SseDescription {
crate::model::SseDescription {
status: self.status,
}
}
}
}
impl SseDescription {
pub fn builder() -> crate::model::sse_description::Builder {
crate::model::sse_description::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 SseStatus {
#[allow(missing_docs)] Disabled,
#[allow(missing_docs)] Disabling,
#[allow(missing_docs)] Enabled,
#[allow(missing_docs)] Enabling,
Unknown(String),
}
impl std::convert::From<&str> for SseStatus {
fn from(s: &str) -> Self {
match s {
"DISABLED" => SseStatus::Disabled,
"DISABLING" => SseStatus::Disabling,
"ENABLED" => SseStatus::Enabled,
"ENABLING" => SseStatus::Enabling,
other => SseStatus::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for SseStatus {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SseStatus::from(s))
}
}
impl SseStatus {
pub fn as_str(&self) -> &str {
match self {
SseStatus::Disabled => "DISABLED",
SseStatus::Disabling => "DISABLING",
SseStatus::Enabled => "ENABLED",
SseStatus::Enabling => "ENABLING",
SseStatus::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["DISABLED", "DISABLING", "ENABLED", "ENABLING"]
}
}
impl AsRef<str> for SseStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ParameterGroupStatus {
pub parameter_group_name: std::option::Option<std::string::String>,
pub parameter_apply_status: std::option::Option<std::string::String>,
pub node_ids_to_reboot: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl ParameterGroupStatus {
pub fn parameter_group_name(&self) -> std::option::Option<&str> {
self.parameter_group_name.as_deref()
}
pub fn parameter_apply_status(&self) -> std::option::Option<&str> {
self.parameter_apply_status.as_deref()
}
pub fn node_ids_to_reboot(&self) -> std::option::Option<&[std::string::String]> {
self.node_ids_to_reboot.as_deref()
}
}
impl std::fmt::Debug for ParameterGroupStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ParameterGroupStatus");
formatter.field("parameter_group_name", &self.parameter_group_name);
formatter.field("parameter_apply_status", &self.parameter_apply_status);
formatter.field("node_ids_to_reboot", &self.node_ids_to_reboot);
formatter.finish()
}
}
pub mod parameter_group_status {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_group_name: std::option::Option<std::string::String>,
pub(crate) parameter_apply_status: std::option::Option<std::string::String>,
pub(crate) node_ids_to_reboot: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn parameter_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_group_name = Some(input.into());
self
}
pub fn set_parameter_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_group_name = input;
self
}
pub fn parameter_apply_status(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_apply_status = Some(input.into());
self
}
pub fn set_parameter_apply_status(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_apply_status = input;
self
}
pub fn node_ids_to_reboot(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.node_ids_to_reboot.unwrap_or_default();
v.push(input.into());
self.node_ids_to_reboot = Some(v);
self
}
pub fn set_node_ids_to_reboot(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.node_ids_to_reboot = input;
self
}
pub fn build(self) -> crate::model::ParameterGroupStatus {
crate::model::ParameterGroupStatus {
parameter_group_name: self.parameter_group_name,
parameter_apply_status: self.parameter_apply_status,
node_ids_to_reboot: self.node_ids_to_reboot,
}
}
}
}
impl ParameterGroupStatus {
pub fn builder() -> crate::model::parameter_group_status::Builder {
crate::model::parameter_group_status::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SecurityGroupMembership {
pub security_group_identifier: std::option::Option<std::string::String>,
pub status: std::option::Option<std::string::String>,
}
impl SecurityGroupMembership {
pub fn security_group_identifier(&self) -> std::option::Option<&str> {
self.security_group_identifier.as_deref()
}
pub fn status(&self) -> std::option::Option<&str> {
self.status.as_deref()
}
}
impl std::fmt::Debug for SecurityGroupMembership {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SecurityGroupMembership");
formatter.field("security_group_identifier", &self.security_group_identifier);
formatter.field("status", &self.status);
formatter.finish()
}
}
pub mod security_group_membership {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) security_group_identifier: std::option::Option<std::string::String>,
pub(crate) status: std::option::Option<std::string::String>,
}
impl Builder {
pub fn security_group_identifier(mut self, input: impl Into<std::string::String>) -> Self {
self.security_group_identifier = Some(input.into());
self
}
pub fn set_security_group_identifier(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_group_identifier = input;
self
}
pub fn status(mut self, input: impl Into<std::string::String>) -> Self {
self.status = Some(input.into());
self
}
pub fn set_status(mut self, input: std::option::Option<std::string::String>) -> Self {
self.status = input;
self
}
pub fn build(self) -> crate::model::SecurityGroupMembership {
crate::model::SecurityGroupMembership {
security_group_identifier: self.security_group_identifier,
status: self.status,
}
}
}
}
impl SecurityGroupMembership {
pub fn builder() -> crate::model::security_group_membership::Builder {
crate::model::security_group_membership::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct NotificationConfiguration {
pub topic_arn: std::option::Option<std::string::String>,
pub topic_status: std::option::Option<std::string::String>,
}
impl NotificationConfiguration {
pub fn topic_arn(&self) -> std::option::Option<&str> {
self.topic_arn.as_deref()
}
pub fn topic_status(&self) -> std::option::Option<&str> {
self.topic_status.as_deref()
}
}
impl std::fmt::Debug for NotificationConfiguration {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("NotificationConfiguration");
formatter.field("topic_arn", &self.topic_arn);
formatter.field("topic_status", &self.topic_status);
formatter.finish()
}
}
pub mod notification_configuration {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) topic_arn: std::option::Option<std::string::String>,
pub(crate) topic_status: std::option::Option<std::string::String>,
}
impl Builder {
pub fn topic_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.topic_arn = Some(input.into());
self
}
pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.topic_arn = input;
self
}
pub fn topic_status(mut self, input: impl Into<std::string::String>) -> Self {
self.topic_status = Some(input.into());
self
}
pub fn set_topic_status(mut self, input: std::option::Option<std::string::String>) -> Self {
self.topic_status = input;
self
}
pub fn build(self) -> crate::model::NotificationConfiguration {
crate::model::NotificationConfiguration {
topic_arn: self.topic_arn,
topic_status: self.topic_status,
}
}
}
}
impl NotificationConfiguration {
pub fn builder() -> crate::model::notification_configuration::Builder {
crate::model::notification_configuration::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Node {
pub node_id: std::option::Option<std::string::String>,
pub endpoint: std::option::Option<crate::model::Endpoint>,
pub node_create_time: std::option::Option<aws_smithy_types::DateTime>,
pub availability_zone: std::option::Option<std::string::String>,
pub node_status: std::option::Option<std::string::String>,
pub parameter_group_status: std::option::Option<std::string::String>,
}
impl Node {
pub fn node_id(&self) -> std::option::Option<&str> {
self.node_id.as_deref()
}
pub fn endpoint(&self) -> std::option::Option<&crate::model::Endpoint> {
self.endpoint.as_ref()
}
pub fn node_create_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.node_create_time.as_ref()
}
pub fn availability_zone(&self) -> std::option::Option<&str> {
self.availability_zone.as_deref()
}
pub fn node_status(&self) -> std::option::Option<&str> {
self.node_status.as_deref()
}
pub fn parameter_group_status(&self) -> std::option::Option<&str> {
self.parameter_group_status.as_deref()
}
}
impl std::fmt::Debug for Node {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Node");
formatter.field("node_id", &self.node_id);
formatter.field("endpoint", &self.endpoint);
formatter.field("node_create_time", &self.node_create_time);
formatter.field("availability_zone", &self.availability_zone);
formatter.field("node_status", &self.node_status);
formatter.field("parameter_group_status", &self.parameter_group_status);
formatter.finish()
}
}
pub mod node {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) node_id: std::option::Option<std::string::String>,
pub(crate) endpoint: std::option::Option<crate::model::Endpoint>,
pub(crate) node_create_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) availability_zone: std::option::Option<std::string::String>,
pub(crate) node_status: std::option::Option<std::string::String>,
pub(crate) parameter_group_status: std::option::Option<std::string::String>,
}
impl Builder {
pub fn node_id(mut self, input: impl Into<std::string::String>) -> Self {
self.node_id = Some(input.into());
self
}
pub fn set_node_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.node_id = input;
self
}
pub fn endpoint(mut self, input: crate::model::Endpoint) -> Self {
self.endpoint = Some(input);
self
}
pub fn set_endpoint(mut self, input: std::option::Option<crate::model::Endpoint>) -> Self {
self.endpoint = input;
self
}
pub fn node_create_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.node_create_time = Some(input);
self
}
pub fn set_node_create_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.node_create_time = input;
self
}
pub fn availability_zone(mut self, input: impl Into<std::string::String>) -> Self {
self.availability_zone = Some(input.into());
self
}
pub fn set_availability_zone(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.availability_zone = input;
self
}
pub fn node_status(mut self, input: impl Into<std::string::String>) -> Self {
self.node_status = Some(input.into());
self
}
pub fn set_node_status(mut self, input: std::option::Option<std::string::String>) -> Self {
self.node_status = input;
self
}
pub fn parameter_group_status(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_group_status = Some(input.into());
self
}
pub fn set_parameter_group_status(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_group_status = input;
self
}
pub fn build(self) -> crate::model::Node {
crate::model::Node {
node_id: self.node_id,
endpoint: self.endpoint,
node_create_time: self.node_create_time,
availability_zone: self.availability_zone,
node_status: self.node_status,
parameter_group_status: self.parameter_group_status,
}
}
}
}
impl Node {
pub fn builder() -> crate::model::node::Builder {
crate::model::node::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Endpoint {
pub address: std::option::Option<std::string::String>,
pub port: i32,
pub url: std::option::Option<std::string::String>,
}
impl Endpoint {
pub fn address(&self) -> std::option::Option<&str> {
self.address.as_deref()
}
pub fn port(&self) -> i32 {
self.port
}
pub fn url(&self) -> std::option::Option<&str> {
self.url.as_deref()
}
}
impl std::fmt::Debug for Endpoint {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Endpoint");
formatter.field("address", &self.address);
formatter.field("port", &self.port);
formatter.field("url", &self.url);
formatter.finish()
}
}
pub mod endpoint {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) address: std::option::Option<std::string::String>,
pub(crate) port: std::option::Option<i32>,
pub(crate) url: std::option::Option<std::string::String>,
}
impl Builder {
pub fn address(mut self, input: impl Into<std::string::String>) -> Self {
self.address = Some(input.into());
self
}
pub fn set_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.address = input;
self
}
pub fn port(mut self, input: i32) -> Self {
self.port = Some(input);
self
}
pub fn set_port(mut self, input: std::option::Option<i32>) -> Self {
self.port = input;
self
}
pub fn url(mut self, input: impl Into<std::string::String>) -> Self {
self.url = Some(input.into());
self
}
pub fn set_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.url = input;
self
}
pub fn build(self) -> crate::model::Endpoint {
crate::model::Endpoint {
address: self.address,
port: self.port.unwrap_or_default(),
url: self.url,
}
}
}
}
impl Endpoint {
pub fn builder() -> crate::model::endpoint::Builder {
crate::model::endpoint::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Tag {
pub key: std::option::Option<std::string::String>,
pub value: std::option::Option<std::string::String>,
}
impl Tag {
pub fn key(&self) -> std::option::Option<&str> {
self.key.as_deref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
}
impl std::fmt::Debug for Tag {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Tag");
formatter.field("key", &self.key);
formatter.field("value", &self.value);
formatter.finish()
}
}
pub mod tag {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) key: std::option::Option<std::string::String>,
pub(crate) value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn key(mut self, input: impl Into<std::string::String>) -> Self {
self.key = Some(input.into());
self
}
pub fn set_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.key = input;
self
}
pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
self.value = Some(input.into());
self
}
pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
self.value = input;
self
}
pub fn build(self) -> crate::model::Tag {
crate::model::Tag {
key: self.key,
value: self.value,
}
}
}
}
impl Tag {
pub fn builder() -> crate::model::tag::Builder {
crate::model::tag::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Parameter {
pub parameter_name: std::option::Option<std::string::String>,
pub parameter_type: std::option::Option<crate::model::ParameterType>,
pub parameter_value: std::option::Option<std::string::String>,
pub node_type_specific_values:
std::option::Option<std::vec::Vec<crate::model::NodeTypeSpecificValue>>,
pub description: std::option::Option<std::string::String>,
pub source: std::option::Option<std::string::String>,
pub data_type: std::option::Option<std::string::String>,
pub allowed_values: std::option::Option<std::string::String>,
pub is_modifiable: std::option::Option<crate::model::IsModifiable>,
pub change_type: std::option::Option<crate::model::ChangeType>,
}
impl Parameter {
pub fn parameter_name(&self) -> std::option::Option<&str> {
self.parameter_name.as_deref()
}
pub fn parameter_type(&self) -> std::option::Option<&crate::model::ParameterType> {
self.parameter_type.as_ref()
}
pub fn parameter_value(&self) -> std::option::Option<&str> {
self.parameter_value.as_deref()
}
pub fn node_type_specific_values(
&self,
) -> std::option::Option<&[crate::model::NodeTypeSpecificValue]> {
self.node_type_specific_values.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn source(&self) -> std::option::Option<&str> {
self.source.as_deref()
}
pub fn data_type(&self) -> std::option::Option<&str> {
self.data_type.as_deref()
}
pub fn allowed_values(&self) -> std::option::Option<&str> {
self.allowed_values.as_deref()
}
pub fn is_modifiable(&self) -> std::option::Option<&crate::model::IsModifiable> {
self.is_modifiable.as_ref()
}
pub fn change_type(&self) -> std::option::Option<&crate::model::ChangeType> {
self.change_type.as_ref()
}
}
impl std::fmt::Debug for Parameter {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Parameter");
formatter.field("parameter_name", &self.parameter_name);
formatter.field("parameter_type", &self.parameter_type);
formatter.field("parameter_value", &self.parameter_value);
formatter.field("node_type_specific_values", &self.node_type_specific_values);
formatter.field("description", &self.description);
formatter.field("source", &self.source);
formatter.field("data_type", &self.data_type);
formatter.field("allowed_values", &self.allowed_values);
formatter.field("is_modifiable", &self.is_modifiable);
formatter.field("change_type", &self.change_type);
formatter.finish()
}
}
pub mod parameter {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_name: std::option::Option<std::string::String>,
pub(crate) parameter_type: std::option::Option<crate::model::ParameterType>,
pub(crate) parameter_value: std::option::Option<std::string::String>,
pub(crate) node_type_specific_values:
std::option::Option<std::vec::Vec<crate::model::NodeTypeSpecificValue>>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) source: std::option::Option<std::string::String>,
pub(crate) data_type: std::option::Option<std::string::String>,
pub(crate) allowed_values: std::option::Option<std::string::String>,
pub(crate) is_modifiable: std::option::Option<crate::model::IsModifiable>,
pub(crate) change_type: std::option::Option<crate::model::ChangeType>,
}
impl Builder {
pub fn parameter_name(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_name = Some(input.into());
self
}
pub fn set_parameter_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_name = input;
self
}
pub fn parameter_type(mut self, input: crate::model::ParameterType) -> Self {
self.parameter_type = Some(input);
self
}
pub fn set_parameter_type(
mut self,
input: std::option::Option<crate::model::ParameterType>,
) -> Self {
self.parameter_type = input;
self
}
pub fn parameter_value(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_value = Some(input.into());
self
}
pub fn set_parameter_value(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_value = input;
self
}
pub fn node_type_specific_values(
mut self,
input: crate::model::NodeTypeSpecificValue,
) -> Self {
let mut v = self.node_type_specific_values.unwrap_or_default();
v.push(input);
self.node_type_specific_values = Some(v);
self
}
pub fn set_node_type_specific_values(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::NodeTypeSpecificValue>>,
) -> Self {
self.node_type_specific_values = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = 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 data_type(mut self, input: impl Into<std::string::String>) -> Self {
self.data_type = Some(input.into());
self
}
pub fn set_data_type(mut self, input: std::option::Option<std::string::String>) -> Self {
self.data_type = input;
self
}
pub fn allowed_values(mut self, input: impl Into<std::string::String>) -> Self {
self.allowed_values = Some(input.into());
self
}
pub fn set_allowed_values(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.allowed_values = input;
self
}
pub fn is_modifiable(mut self, input: crate::model::IsModifiable) -> Self {
self.is_modifiable = Some(input);
self
}
pub fn set_is_modifiable(
mut self,
input: std::option::Option<crate::model::IsModifiable>,
) -> Self {
self.is_modifiable = input;
self
}
pub fn change_type(mut self, input: crate::model::ChangeType) -> Self {
self.change_type = Some(input);
self
}
pub fn set_change_type(
mut self,
input: std::option::Option<crate::model::ChangeType>,
) -> Self {
self.change_type = input;
self
}
pub fn build(self) -> crate::model::Parameter {
crate::model::Parameter {
parameter_name: self.parameter_name,
parameter_type: self.parameter_type,
parameter_value: self.parameter_value,
node_type_specific_values: self.node_type_specific_values,
description: self.description,
source: self.source,
data_type: self.data_type,
allowed_values: self.allowed_values,
is_modifiable: self.is_modifiable,
change_type: self.change_type,
}
}
}
}
impl Parameter {
pub fn builder() -> crate::model::parameter::Builder {
crate::model::parameter::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 ChangeType {
#[allow(missing_docs)] Immediate,
#[allow(missing_docs)] RequiresReboot,
Unknown(String),
}
impl std::convert::From<&str> for ChangeType {
fn from(s: &str) -> Self {
match s {
"IMMEDIATE" => ChangeType::Immediate,
"REQUIRES_REBOOT" => ChangeType::RequiresReboot,
other => ChangeType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for ChangeType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ChangeType::from(s))
}
}
impl ChangeType {
pub fn as_str(&self) -> &str {
match self {
ChangeType::Immediate => "IMMEDIATE",
ChangeType::RequiresReboot => "REQUIRES_REBOOT",
ChangeType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["IMMEDIATE", "REQUIRES_REBOOT"]
}
}
impl AsRef<str> for ChangeType {
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 IsModifiable {
#[allow(missing_docs)] Conditional,
#[allow(missing_docs)] False,
#[allow(missing_docs)] True,
Unknown(String),
}
impl std::convert::From<&str> for IsModifiable {
fn from(s: &str) -> Self {
match s {
"CONDITIONAL" => IsModifiable::Conditional,
"FALSE" => IsModifiable::False,
"TRUE" => IsModifiable::True,
other => IsModifiable::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for IsModifiable {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(IsModifiable::from(s))
}
}
impl IsModifiable {
pub fn as_str(&self) -> &str {
match self {
IsModifiable::Conditional => "CONDITIONAL",
IsModifiable::False => "FALSE",
IsModifiable::True => "TRUE",
IsModifiable::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["CONDITIONAL", "FALSE", "TRUE"]
}
}
impl AsRef<str> for IsModifiable {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct NodeTypeSpecificValue {
pub node_type: std::option::Option<std::string::String>,
pub value: std::option::Option<std::string::String>,
}
impl NodeTypeSpecificValue {
pub fn node_type(&self) -> std::option::Option<&str> {
self.node_type.as_deref()
}
pub fn value(&self) -> std::option::Option<&str> {
self.value.as_deref()
}
}
impl std::fmt::Debug for NodeTypeSpecificValue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("NodeTypeSpecificValue");
formatter.field("node_type", &self.node_type);
formatter.field("value", &self.value);
formatter.finish()
}
}
pub mod node_type_specific_value {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) node_type: std::option::Option<std::string::String>,
pub(crate) value: std::option::Option<std::string::String>,
}
impl Builder {
pub fn node_type(mut self, input: impl Into<std::string::String>) -> Self {
self.node_type = Some(input.into());
self
}
pub fn set_node_type(mut self, input: std::option::Option<std::string::String>) -> Self {
self.node_type = input;
self
}
pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
self.value = Some(input.into());
self
}
pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
self.value = input;
self
}
pub fn build(self) -> crate::model::NodeTypeSpecificValue {
crate::model::NodeTypeSpecificValue {
node_type: self.node_type,
value: self.value,
}
}
}
}
impl NodeTypeSpecificValue {
pub fn builder() -> crate::model::node_type_specific_value::Builder {
crate::model::node_type_specific_value::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 ParameterType {
#[allow(missing_docs)] Default,
#[allow(missing_docs)] NodeTypeSpecific,
Unknown(String),
}
impl std::convert::From<&str> for ParameterType {
fn from(s: &str) -> Self {
match s {
"DEFAULT" => ParameterType::Default,
"NODE_TYPE_SPECIFIC" => ParameterType::NodeTypeSpecific,
other => ParameterType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for ParameterType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(ParameterType::from(s))
}
}
impl ParameterType {
pub fn as_str(&self) -> &str {
match self {
ParameterType::Default => "DEFAULT",
ParameterType::NodeTypeSpecific => "NODE_TYPE_SPECIFIC",
ParameterType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["DEFAULT", "NODE_TYPE_SPECIFIC"]
}
}
impl AsRef<str> for ParameterType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct Event {
pub source_name: std::option::Option<std::string::String>,
pub source_type: std::option::Option<crate::model::SourceType>,
pub message: std::option::Option<std::string::String>,
pub date: std::option::Option<aws_smithy_types::DateTime>,
}
impl Event {
pub fn source_name(&self) -> std::option::Option<&str> {
self.source_name.as_deref()
}
pub fn source_type(&self) -> std::option::Option<&crate::model::SourceType> {
self.source_type.as_ref()
}
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
pub fn date(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.date.as_ref()
}
}
impl std::fmt::Debug for Event {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Event");
formatter.field("source_name", &self.source_name);
formatter.field("source_type", &self.source_type);
formatter.field("message", &self.message);
formatter.field("date", &self.date);
formatter.finish()
}
}
pub mod event {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) source_name: std::option::Option<std::string::String>,
pub(crate) source_type: std::option::Option<crate::model::SourceType>,
pub(crate) message: std::option::Option<std::string::String>,
pub(crate) date: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
pub fn source_name(mut self, input: impl Into<std::string::String>) -> Self {
self.source_name = Some(input.into());
self
}
pub fn set_source_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.source_name = input;
self
}
pub fn source_type(mut self, input: crate::model::SourceType) -> Self {
self.source_type = Some(input);
self
}
pub fn set_source_type(
mut self,
input: std::option::Option<crate::model::SourceType>,
) -> Self {
self.source_type = input;
self
}
pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn date(mut self, input: aws_smithy_types::DateTime) -> Self {
self.date = Some(input);
self
}
pub fn set_date(mut self, input: std::option::Option<aws_smithy_types::DateTime>) -> Self {
self.date = input;
self
}
pub fn build(self) -> crate::model::Event {
crate::model::Event {
source_name: self.source_name,
source_type: self.source_type,
message: self.message,
date: self.date,
}
}
}
}
impl Event {
pub fn builder() -> crate::model::event::Builder {
crate::model::event::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 SourceType {
#[allow(missing_docs)] Cluster,
#[allow(missing_docs)] ParameterGroup,
#[allow(missing_docs)] SubnetGroup,
Unknown(String),
}
impl std::convert::From<&str> for SourceType {
fn from(s: &str) -> Self {
match s {
"CLUSTER" => SourceType::Cluster,
"PARAMETER_GROUP" => SourceType::ParameterGroup,
"SUBNET_GROUP" => SourceType::SubnetGroup,
other => SourceType::Unknown(other.to_owned()),
}
}
}
impl std::str::FromStr for SourceType {
type Err = std::convert::Infallible;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Ok(SourceType::from(s))
}
}
impl SourceType {
pub fn as_str(&self) -> &str {
match self {
SourceType::Cluster => "CLUSTER",
SourceType::ParameterGroup => "PARAMETER_GROUP",
SourceType::SubnetGroup => "SUBNET_GROUP",
SourceType::Unknown(s) => s.as_ref(),
}
}
pub fn values() -> &'static [&'static str] {
&["CLUSTER", "PARAMETER_GROUP", "SUBNET_GROUP"]
}
}
impl AsRef<str> for SourceType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SseSpecification {
pub enabled: std::option::Option<bool>,
}
impl SseSpecification {
pub fn enabled(&self) -> std::option::Option<bool> {
self.enabled
}
}
impl std::fmt::Debug for SseSpecification {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SseSpecification");
formatter.field("enabled", &self.enabled);
formatter.finish()
}
}
pub mod sse_specification {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) enabled: std::option::Option<bool>,
}
impl Builder {
pub fn enabled(mut self, input: bool) -> Self {
self.enabled = Some(input);
self
}
pub fn set_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.enabled = input;
self
}
pub fn build(self) -> crate::model::SseSpecification {
crate::model::SseSpecification {
enabled: self.enabled,
}
}
}
}
impl SseSpecification {
pub fn builder() -> crate::model::sse_specification::Builder {
crate::model::sse_specification::Builder::default()
}
}