#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateSubnetGroupOutput {
pub subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl UpdateSubnetGroupOutput {
pub fn subnet_group(&self) -> std::option::Option<&crate::model::SubnetGroup> {
self.subnet_group.as_ref()
}
}
impl std::fmt::Debug for UpdateSubnetGroupOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateSubnetGroupOutput");
formatter.field("subnet_group", &self.subnet_group);
formatter.finish()
}
}
pub mod update_subnet_group_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl Builder {
pub fn subnet_group(mut self, input: crate::model::SubnetGroup) -> Self {
self.subnet_group = Some(input);
self
}
pub fn set_subnet_group(
mut self,
input: std::option::Option<crate::model::SubnetGroup>,
) -> Self {
self.subnet_group = input;
self
}
pub fn build(self) -> crate::output::UpdateSubnetGroupOutput {
crate::output::UpdateSubnetGroupOutput {
subnet_group: self.subnet_group,
}
}
}
}
impl UpdateSubnetGroupOutput {
pub fn builder() -> crate::output::update_subnet_group_output::Builder {
crate::output::update_subnet_group_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateParameterGroupOutput {
pub parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl UpdateParameterGroupOutput {
pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroup> {
self.parameter_group.as_ref()
}
}
impl std::fmt::Debug for UpdateParameterGroupOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateParameterGroupOutput");
formatter.field("parameter_group", &self.parameter_group);
formatter.finish()
}
}
pub mod update_parameter_group_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl Builder {
pub fn parameter_group(mut self, input: crate::model::ParameterGroup) -> Self {
self.parameter_group = Some(input);
self
}
pub fn set_parameter_group(
mut self,
input: std::option::Option<crate::model::ParameterGroup>,
) -> Self {
self.parameter_group = input;
self
}
pub fn build(self) -> crate::output::UpdateParameterGroupOutput {
crate::output::UpdateParameterGroupOutput {
parameter_group: self.parameter_group,
}
}
}
}
impl UpdateParameterGroupOutput {
pub fn builder() -> crate::output::update_parameter_group_output::Builder {
crate::output::update_parameter_group_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateClusterOutput {
pub cluster: std::option::Option<crate::model::Cluster>,
}
impl UpdateClusterOutput {
pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
self.cluster.as_ref()
}
}
impl std::fmt::Debug for UpdateClusterOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateClusterOutput");
formatter.field("cluster", &self.cluster);
formatter.finish()
}
}
pub mod update_cluster_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster: std::option::Option<crate::model::Cluster>,
}
impl Builder {
pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
self.cluster = Some(input);
self
}
pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
self.cluster = input;
self
}
pub fn build(self) -> crate::output::UpdateClusterOutput {
crate::output::UpdateClusterOutput {
cluster: self.cluster,
}
}
}
}
impl UpdateClusterOutput {
pub fn builder() -> crate::output::update_cluster_output::Builder {
crate::output::update_cluster_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagResourceOutput {
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl UntagResourceOutput {
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for UntagResourceOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UntagResourceOutput");
formatter.field("tags", &self.tags);
formatter.finish()
}
}
pub mod untag_resource_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(self) -> crate::output::UntagResourceOutput {
crate::output::UntagResourceOutput { tags: self.tags }
}
}
}
impl UntagResourceOutput {
pub fn builder() -> crate::output::untag_resource_output::Builder {
crate::output::untag_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TagResourceOutput {
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl TagResourceOutput {
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for TagResourceOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("TagResourceOutput");
formatter.field("tags", &self.tags);
formatter.finish()
}
}
pub mod tag_resource_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(self) -> crate::output::TagResourceOutput {
crate::output::TagResourceOutput { tags: self.tags }
}
}
}
impl TagResourceOutput {
pub fn builder() -> crate::output::tag_resource_output::Builder {
crate::output::tag_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RebootNodeOutput {
pub cluster: std::option::Option<crate::model::Cluster>,
}
impl RebootNodeOutput {
pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
self.cluster.as_ref()
}
}
impl std::fmt::Debug for RebootNodeOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RebootNodeOutput");
formatter.field("cluster", &self.cluster);
formatter.finish()
}
}
pub mod reboot_node_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster: std::option::Option<crate::model::Cluster>,
}
impl Builder {
pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
self.cluster = Some(input);
self
}
pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
self.cluster = input;
self
}
pub fn build(self) -> crate::output::RebootNodeOutput {
crate::output::RebootNodeOutput {
cluster: self.cluster,
}
}
}
}
impl RebootNodeOutput {
pub fn builder() -> crate::output::reboot_node_output::Builder {
crate::output::reboot_node_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsOutput {
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsOutput {
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
impl std::fmt::Debug for ListTagsOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListTagsOutput");
formatter.field("tags", &self.tags);
formatter.field("next_token", &self.next_token);
formatter.finish()
}
}
pub mod list_tags_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListTagsOutput {
crate::output::ListTagsOutput {
tags: self.tags,
next_token: self.next_token,
}
}
}
}
impl ListTagsOutput {
pub fn builder() -> crate::output::list_tags_output::Builder {
crate::output::list_tags_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct IncreaseReplicationFactorOutput {
pub cluster: std::option::Option<crate::model::Cluster>,
}
impl IncreaseReplicationFactorOutput {
pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
self.cluster.as_ref()
}
}
impl std::fmt::Debug for IncreaseReplicationFactorOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("IncreaseReplicationFactorOutput");
formatter.field("cluster", &self.cluster);
formatter.finish()
}
}
pub mod increase_replication_factor_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster: std::option::Option<crate::model::Cluster>,
}
impl Builder {
pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
self.cluster = Some(input);
self
}
pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
self.cluster = input;
self
}
pub fn build(self) -> crate::output::IncreaseReplicationFactorOutput {
crate::output::IncreaseReplicationFactorOutput {
cluster: self.cluster,
}
}
}
}
impl IncreaseReplicationFactorOutput {
pub fn builder() -> crate::output::increase_replication_factor_output::Builder {
crate::output::increase_replication_factor_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeSubnetGroupsOutput {
pub next_token: std::option::Option<std::string::String>,
pub subnet_groups: std::option::Option<std::vec::Vec<crate::model::SubnetGroup>>,
}
impl DescribeSubnetGroupsOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn subnet_groups(&self) -> std::option::Option<&[crate::model::SubnetGroup]> {
self.subnet_groups.as_deref()
}
}
impl std::fmt::Debug for DescribeSubnetGroupsOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeSubnetGroupsOutput");
formatter.field("next_token", &self.next_token);
formatter.field("subnet_groups", &self.subnet_groups);
formatter.finish()
}
}
pub mod describe_subnet_groups_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) subnet_groups: std::option::Option<std::vec::Vec<crate::model::SubnetGroup>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn subnet_groups(mut self, input: crate::model::SubnetGroup) -> Self {
let mut v = self.subnet_groups.unwrap_or_default();
v.push(input);
self.subnet_groups = Some(v);
self
}
pub fn set_subnet_groups(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SubnetGroup>>,
) -> Self {
self.subnet_groups = input;
self
}
pub fn build(self) -> crate::output::DescribeSubnetGroupsOutput {
crate::output::DescribeSubnetGroupsOutput {
next_token: self.next_token,
subnet_groups: self.subnet_groups,
}
}
}
}
impl DescribeSubnetGroupsOutput {
pub fn builder() -> crate::output::describe_subnet_groups_output::Builder {
crate::output::describe_subnet_groups_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeParametersOutput {
pub next_token: std::option::Option<std::string::String>,
pub parameters: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
}
impl DescribeParametersOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn parameters(&self) -> std::option::Option<&[crate::model::Parameter]> {
self.parameters.as_deref()
}
}
impl std::fmt::Debug for DescribeParametersOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeParametersOutput");
formatter.field("next_token", &self.next_token);
formatter.field("parameters", &self.parameters);
formatter.finish()
}
}
pub mod describe_parameters_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) parameters: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn parameters(mut self, input: crate::model::Parameter) -> Self {
let mut v = self.parameters.unwrap_or_default();
v.push(input);
self.parameters = Some(v);
self
}
pub fn set_parameters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
) -> Self {
self.parameters = input;
self
}
pub fn build(self) -> crate::output::DescribeParametersOutput {
crate::output::DescribeParametersOutput {
next_token: self.next_token,
parameters: self.parameters,
}
}
}
}
impl DescribeParametersOutput {
pub fn builder() -> crate::output::describe_parameters_output::Builder {
crate::output::describe_parameters_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeParameterGroupsOutput {
pub next_token: std::option::Option<std::string::String>,
pub parameter_groups: std::option::Option<std::vec::Vec<crate::model::ParameterGroup>>,
}
impl DescribeParameterGroupsOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn parameter_groups(&self) -> std::option::Option<&[crate::model::ParameterGroup]> {
self.parameter_groups.as_deref()
}
}
impl std::fmt::Debug for DescribeParameterGroupsOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeParameterGroupsOutput");
formatter.field("next_token", &self.next_token);
formatter.field("parameter_groups", &self.parameter_groups);
formatter.finish()
}
}
pub mod describe_parameter_groups_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) parameter_groups:
std::option::Option<std::vec::Vec<crate::model::ParameterGroup>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn parameter_groups(mut self, input: crate::model::ParameterGroup) -> Self {
let mut v = self.parameter_groups.unwrap_or_default();
v.push(input);
self.parameter_groups = Some(v);
self
}
pub fn set_parameter_groups(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ParameterGroup>>,
) -> Self {
self.parameter_groups = input;
self
}
pub fn build(self) -> crate::output::DescribeParameterGroupsOutput {
crate::output::DescribeParameterGroupsOutput {
next_token: self.next_token,
parameter_groups: self.parameter_groups,
}
}
}
}
impl DescribeParameterGroupsOutput {
pub fn builder() -> crate::output::describe_parameter_groups_output::Builder {
crate::output::describe_parameter_groups_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventsOutput {
pub next_token: std::option::Option<std::string::String>,
pub events: std::option::Option<std::vec::Vec<crate::model::Event>>,
}
impl DescribeEventsOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn events(&self) -> std::option::Option<&[crate::model::Event]> {
self.events.as_deref()
}
}
impl std::fmt::Debug for DescribeEventsOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeEventsOutput");
formatter.field("next_token", &self.next_token);
formatter.field("events", &self.events);
formatter.finish()
}
}
pub mod describe_events_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) events: std::option::Option<std::vec::Vec<crate::model::Event>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn events(mut self, input: crate::model::Event) -> Self {
let mut v = self.events.unwrap_or_default();
v.push(input);
self.events = Some(v);
self
}
pub fn set_events(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Event>>,
) -> Self {
self.events = input;
self
}
pub fn build(self) -> crate::output::DescribeEventsOutput {
crate::output::DescribeEventsOutput {
next_token: self.next_token,
events: self.events,
}
}
}
}
impl DescribeEventsOutput {
pub fn builder() -> crate::output::describe_events_output::Builder {
crate::output::describe_events_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDefaultParametersOutput {
pub next_token: std::option::Option<std::string::String>,
pub parameters: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
}
impl DescribeDefaultParametersOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn parameters(&self) -> std::option::Option<&[crate::model::Parameter]> {
self.parameters.as_deref()
}
}
impl std::fmt::Debug for DescribeDefaultParametersOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeDefaultParametersOutput");
formatter.field("next_token", &self.next_token);
formatter.field("parameters", &self.parameters);
formatter.finish()
}
}
pub mod describe_default_parameters_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) parameters: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn parameters(mut self, input: crate::model::Parameter) -> Self {
let mut v = self.parameters.unwrap_or_default();
v.push(input);
self.parameters = Some(v);
self
}
pub fn set_parameters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Parameter>>,
) -> Self {
self.parameters = input;
self
}
pub fn build(self) -> crate::output::DescribeDefaultParametersOutput {
crate::output::DescribeDefaultParametersOutput {
next_token: self.next_token,
parameters: self.parameters,
}
}
}
}
impl DescribeDefaultParametersOutput {
pub fn builder() -> crate::output::describe_default_parameters_output::Builder {
crate::output::describe_default_parameters_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeClustersOutput {
pub next_token: std::option::Option<std::string::String>,
pub clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
}
impl DescribeClustersOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn clusters(&self) -> std::option::Option<&[crate::model::Cluster]> {
self.clusters.as_deref()
}
}
impl std::fmt::Debug for DescribeClustersOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeClustersOutput");
formatter.field("next_token", &self.next_token);
formatter.field("clusters", &self.clusters);
formatter.finish()
}
}
pub mod describe_clusters_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) clusters: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn clusters(mut self, input: crate::model::Cluster) -> Self {
let mut v = self.clusters.unwrap_or_default();
v.push(input);
self.clusters = Some(v);
self
}
pub fn set_clusters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Cluster>>,
) -> Self {
self.clusters = input;
self
}
pub fn build(self) -> crate::output::DescribeClustersOutput {
crate::output::DescribeClustersOutput {
next_token: self.next_token,
clusters: self.clusters,
}
}
}
}
impl DescribeClustersOutput {
pub fn builder() -> crate::output::describe_clusters_output::Builder {
crate::output::describe_clusters_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteSubnetGroupOutput {
pub deletion_message: std::option::Option<std::string::String>,
}
impl DeleteSubnetGroupOutput {
pub fn deletion_message(&self) -> std::option::Option<&str> {
self.deletion_message.as_deref()
}
}
impl std::fmt::Debug for DeleteSubnetGroupOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteSubnetGroupOutput");
formatter.field("deletion_message", &self.deletion_message);
formatter.finish()
}
}
pub mod delete_subnet_group_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) deletion_message: std::option::Option<std::string::String>,
}
impl Builder {
pub fn deletion_message(mut self, input: impl Into<std::string::String>) -> Self {
self.deletion_message = Some(input.into());
self
}
pub fn set_deletion_message(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deletion_message = input;
self
}
pub fn build(self) -> crate::output::DeleteSubnetGroupOutput {
crate::output::DeleteSubnetGroupOutput {
deletion_message: self.deletion_message,
}
}
}
}
impl DeleteSubnetGroupOutput {
pub fn builder() -> crate::output::delete_subnet_group_output::Builder {
crate::output::delete_subnet_group_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteParameterGroupOutput {
pub deletion_message: std::option::Option<std::string::String>,
}
impl DeleteParameterGroupOutput {
pub fn deletion_message(&self) -> std::option::Option<&str> {
self.deletion_message.as_deref()
}
}
impl std::fmt::Debug for DeleteParameterGroupOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteParameterGroupOutput");
formatter.field("deletion_message", &self.deletion_message);
formatter.finish()
}
}
pub mod delete_parameter_group_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) deletion_message: std::option::Option<std::string::String>,
}
impl Builder {
pub fn deletion_message(mut self, input: impl Into<std::string::String>) -> Self {
self.deletion_message = Some(input.into());
self
}
pub fn set_deletion_message(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.deletion_message = input;
self
}
pub fn build(self) -> crate::output::DeleteParameterGroupOutput {
crate::output::DeleteParameterGroupOutput {
deletion_message: self.deletion_message,
}
}
}
}
impl DeleteParameterGroupOutput {
pub fn builder() -> crate::output::delete_parameter_group_output::Builder {
crate::output::delete_parameter_group_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteClusterOutput {
pub cluster: std::option::Option<crate::model::Cluster>,
}
impl DeleteClusterOutput {
pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
self.cluster.as_ref()
}
}
impl std::fmt::Debug for DeleteClusterOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteClusterOutput");
formatter.field("cluster", &self.cluster);
formatter.finish()
}
}
pub mod delete_cluster_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster: std::option::Option<crate::model::Cluster>,
}
impl Builder {
pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
self.cluster = Some(input);
self
}
pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
self.cluster = input;
self
}
pub fn build(self) -> crate::output::DeleteClusterOutput {
crate::output::DeleteClusterOutput {
cluster: self.cluster,
}
}
}
}
impl DeleteClusterOutput {
pub fn builder() -> crate::output::delete_cluster_output::Builder {
crate::output::delete_cluster_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DecreaseReplicationFactorOutput {
pub cluster: std::option::Option<crate::model::Cluster>,
}
impl DecreaseReplicationFactorOutput {
pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
self.cluster.as_ref()
}
}
impl std::fmt::Debug for DecreaseReplicationFactorOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DecreaseReplicationFactorOutput");
formatter.field("cluster", &self.cluster);
formatter.finish()
}
}
pub mod decrease_replication_factor_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster: std::option::Option<crate::model::Cluster>,
}
impl Builder {
pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
self.cluster = Some(input);
self
}
pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
self.cluster = input;
self
}
pub fn build(self) -> crate::output::DecreaseReplicationFactorOutput {
crate::output::DecreaseReplicationFactorOutput {
cluster: self.cluster,
}
}
}
}
impl DecreaseReplicationFactorOutput {
pub fn builder() -> crate::output::decrease_replication_factor_output::Builder {
crate::output::decrease_replication_factor_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSubnetGroupOutput {
pub subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl CreateSubnetGroupOutput {
pub fn subnet_group(&self) -> std::option::Option<&crate::model::SubnetGroup> {
self.subnet_group.as_ref()
}
}
impl std::fmt::Debug for CreateSubnetGroupOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateSubnetGroupOutput");
formatter.field("subnet_group", &self.subnet_group);
formatter.finish()
}
}
pub mod create_subnet_group_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) subnet_group: std::option::Option<crate::model::SubnetGroup>,
}
impl Builder {
pub fn subnet_group(mut self, input: crate::model::SubnetGroup) -> Self {
self.subnet_group = Some(input);
self
}
pub fn set_subnet_group(
mut self,
input: std::option::Option<crate::model::SubnetGroup>,
) -> Self {
self.subnet_group = input;
self
}
pub fn build(self) -> crate::output::CreateSubnetGroupOutput {
crate::output::CreateSubnetGroupOutput {
subnet_group: self.subnet_group,
}
}
}
}
impl CreateSubnetGroupOutput {
pub fn builder() -> crate::output::create_subnet_group_output::Builder {
crate::output::create_subnet_group_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateParameterGroupOutput {
pub parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl CreateParameterGroupOutput {
pub fn parameter_group(&self) -> std::option::Option<&crate::model::ParameterGroup> {
self.parameter_group.as_ref()
}
}
impl std::fmt::Debug for CreateParameterGroupOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateParameterGroupOutput");
formatter.field("parameter_group", &self.parameter_group);
formatter.finish()
}
}
pub mod create_parameter_group_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) parameter_group: std::option::Option<crate::model::ParameterGroup>,
}
impl Builder {
pub fn parameter_group(mut self, input: crate::model::ParameterGroup) -> Self {
self.parameter_group = Some(input);
self
}
pub fn set_parameter_group(
mut self,
input: std::option::Option<crate::model::ParameterGroup>,
) -> Self {
self.parameter_group = input;
self
}
pub fn build(self) -> crate::output::CreateParameterGroupOutput {
crate::output::CreateParameterGroupOutput {
parameter_group: self.parameter_group,
}
}
}
}
impl CreateParameterGroupOutput {
pub fn builder() -> crate::output::create_parameter_group_output::Builder {
crate::output::create_parameter_group_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateClusterOutput {
pub cluster: std::option::Option<crate::model::Cluster>,
}
impl CreateClusterOutput {
pub fn cluster(&self) -> std::option::Option<&crate::model::Cluster> {
self.cluster.as_ref()
}
}
impl std::fmt::Debug for CreateClusterOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateClusterOutput");
formatter.field("cluster", &self.cluster);
formatter.finish()
}
}
pub mod create_cluster_output {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) cluster: std::option::Option<crate::model::Cluster>,
}
impl Builder {
pub fn cluster(mut self, input: crate::model::Cluster) -> Self {
self.cluster = Some(input);
self
}
pub fn set_cluster(mut self, input: std::option::Option<crate::model::Cluster>) -> Self {
self.cluster = input;
self
}
pub fn build(self) -> crate::output::CreateClusterOutput {
crate::output::CreateClusterOutput {
cluster: self.cluster,
}
}
}
}
impl CreateClusterOutput {
pub fn builder() -> crate::output::create_cluster_output::Builder {
crate::output::create_cluster_output::Builder::default()
}
}