aws_sdk_finspace/operation/create_kx_cluster/

builders.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub use crate::operation::create_kx_cluster::_create_kx_cluster_output::CreateKxClusterOutputBuilder;

pub use crate::operation::create_kx_cluster::_create_kx_cluster_input::CreateKxClusterInputBuilder;

impl crate::operation::create_kx_cluster::builders::CreateKxClusterInputBuilder {
    /// Sends a request with this input using the given client.
    pub async fn send_with(
        self,
        client: &crate::Client,
    ) -> ::std::result::Result<
        crate::operation::create_kx_cluster::CreateKxClusterOutput,
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::create_kx_cluster::CreateKxClusterError,
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
        >,
    > {
        let mut fluent_builder = client.create_kx_cluster();
        fluent_builder.inner = self;
        fluent_builder.send().await
    }
}
/// Fluent builder constructing a request to `CreateKxCluster`.
///
/// <p>Creates a new kdb cluster.</p>
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
pub struct CreateKxClusterFluentBuilder {
    handle: ::std::sync::Arc<crate::client::Handle>,
    inner: crate::operation::create_kx_cluster::builders::CreateKxClusterInputBuilder,
    config_override: ::std::option::Option<crate::config::Builder>,
}
impl
    crate::client::customize::internal::CustomizableSend<
        crate::operation::create_kx_cluster::CreateKxClusterOutput,
        crate::operation::create_kx_cluster::CreateKxClusterError,
    > for CreateKxClusterFluentBuilder
{
    fn send(
        self,
        config_override: crate::config::Builder,
    ) -> crate::client::customize::internal::BoxFuture<
        crate::client::customize::internal::SendResult<
            crate::operation::create_kx_cluster::CreateKxClusterOutput,
            crate::operation::create_kx_cluster::CreateKxClusterError,
        >,
    > {
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
    }
}
impl CreateKxClusterFluentBuilder {
    /// Creates a new `CreateKxClusterFluentBuilder`.
    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
        Self {
            handle,
            inner: ::std::default::Default::default(),
            config_override: ::std::option::Option::None,
        }
    }
    /// Access the CreateKxCluster as a reference.
    pub fn as_input(&self) -> &crate::operation::create_kx_cluster::builders::CreateKxClusterInputBuilder {
        &self.inner
    }
    /// Sends the request and returns the response.
    ///
    /// If an error occurs, an `SdkError` will be returned with additional details that
    /// can be matched against.
    ///
    /// By default, any retryable failures will be retried twice. Retry behavior
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
    /// set when configuring the client.
    pub async fn send(
        self,
    ) -> ::std::result::Result<
        crate::operation::create_kx_cluster::CreateKxClusterOutput,
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::create_kx_cluster::CreateKxClusterError,
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
        >,
    > {
        let input = self
            .inner
            .build()
            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
        let runtime_plugins = crate::operation::create_kx_cluster::CreateKxCluster::operation_runtime_plugins(
            self.handle.runtime_plugins.clone(),
            &self.handle.conf,
            self.config_override,
        );
        crate::operation::create_kx_cluster::CreateKxCluster::orchestrate(&runtime_plugins, input).await
    }

    /// Consumes this builder, creating a customizable operation that can be modified before being sent.
    pub fn customize(
        self,
    ) -> crate::client::customize::CustomizableOperation<
        crate::operation::create_kx_cluster::CreateKxClusterOutput,
        crate::operation::create_kx_cluster::CreateKxClusterError,
        Self,
    > {
        crate::client::customize::CustomizableOperation::new(self)
    }
    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
        self.set_config_override(::std::option::Option::Some(config_override.into()));
        self
    }

    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
        self.config_override = config_override;
        self
    }
    /// <p>A token that ensures idempotency. This token expires in 10 minutes.</p>
    pub fn client_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.client_token(input.into());
        self
    }
    /// <p>A token that ensures idempotency. This token expires in 10 minutes.</p>
    pub fn set_client_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_client_token(input);
        self
    }
    /// <p>A token that ensures idempotency. This token expires in 10 minutes.</p>
    pub fn get_client_token(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_client_token()
    }
    /// <p>A unique identifier for the kdb environment.</p>
    pub fn environment_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.environment_id(input.into());
        self
    }
    /// <p>A unique identifier for the kdb environment.</p>
    pub fn set_environment_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_environment_id(input);
        self
    }
    /// <p>A unique identifier for the kdb environment.</p>
    pub fn get_environment_id(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_environment_id()
    }
    /// <p>A unique name for the cluster that you want to create.</p>
    pub fn cluster_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.cluster_name(input.into());
        self
    }
    /// <p>A unique name for the cluster that you want to create.</p>
    pub fn set_cluster_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_cluster_name(input);
        self
    }
    /// <p>A unique name for the cluster that you want to create.</p>
    pub fn get_cluster_name(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_cluster_name()
    }
    /// <p>Specifies the type of KDB database that is being created. The following types are available:</p>
    /// <ul>
    /// <li>
    /// <p>HDB – A Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed kdb databases mounted to the cluster.</p></li>
    /// <li>
    /// <p>RDB – A Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the <code>savedownStorageConfiguration</code> parameter.</p></li>
    /// <li>
    /// <p>GATEWAY – A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.</p></li>
    /// <li>
    /// <p>GP – A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only <code>SINGLE</code> AZ mode.</p></li>
    /// <li>
    /// <p>Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.</p></li>
    /// </ul>
    pub fn cluster_type(mut self, input: crate::types::KxClusterType) -> Self {
        self.inner = self.inner.cluster_type(input);
        self
    }
    /// <p>Specifies the type of KDB database that is being created. The following types are available:</p>
    /// <ul>
    /// <li>
    /// <p>HDB – A Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed kdb databases mounted to the cluster.</p></li>
    /// <li>
    /// <p>RDB – A Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the <code>savedownStorageConfiguration</code> parameter.</p></li>
    /// <li>
    /// <p>GATEWAY – A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.</p></li>
    /// <li>
    /// <p>GP – A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only <code>SINGLE</code> AZ mode.</p></li>
    /// <li>
    /// <p>Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.</p></li>
    /// </ul>
    pub fn set_cluster_type(mut self, input: ::std::option::Option<crate::types::KxClusterType>) -> Self {
        self.inner = self.inner.set_cluster_type(input);
        self
    }
    /// <p>Specifies the type of KDB database that is being created. The following types are available:</p>
    /// <ul>
    /// <li>
    /// <p>HDB – A Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed kdb databases mounted to the cluster.</p></li>
    /// <li>
    /// <p>RDB – A Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the <code>savedownStorageConfiguration</code> parameter.</p></li>
    /// <li>
    /// <p>GATEWAY – A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.</p></li>
    /// <li>
    /// <p>GP – A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only <code>SINGLE</code> AZ mode.</p></li>
    /// <li>
    /// <p>Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.</p></li>
    /// </ul>
    pub fn get_cluster_type(&self) -> &::std::option::Option<crate::types::KxClusterType> {
        self.inner.get_cluster_type()
    }
    /// <p>A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type <code>Tickerplant</code>, the location of the TP volume on the cluster will be available by using the global variable <code>.aws.tp_log_path</code>.</p>
    pub fn tickerplant_log_configuration(mut self, input: crate::types::TickerplantLogConfiguration) -> Self {
        self.inner = self.inner.tickerplant_log_configuration(input);
        self
    }
    /// <p>A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type <code>Tickerplant</code>, the location of the TP volume on the cluster will be available by using the global variable <code>.aws.tp_log_path</code>.</p>
    pub fn set_tickerplant_log_configuration(mut self, input: ::std::option::Option<crate::types::TickerplantLogConfiguration>) -> Self {
        self.inner = self.inner.set_tickerplant_log_configuration(input);
        self
    }
    /// <p>A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type <code>Tickerplant</code>, the location of the TP volume on the cluster will be available by using the global variable <code>.aws.tp_log_path</code>.</p>
    pub fn get_tickerplant_log_configuration(&self) -> &::std::option::Option<crate::types::TickerplantLogConfiguration> {
        self.inner.get_tickerplant_log_configuration()
    }
    ///
    /// Appends an item to `databases`.
    ///
    /// To override the contents of this collection use [`set_databases`](Self::set_databases).
    ///
    /// <p>A list of databases that will be available for querying.</p>
    pub fn databases(mut self, input: crate::types::KxDatabaseConfiguration) -> Self {
        self.inner = self.inner.databases(input);
        self
    }
    /// <p>A list of databases that will be available for querying.</p>
    pub fn set_databases(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::KxDatabaseConfiguration>>) -> Self {
        self.inner = self.inner.set_databases(input);
        self
    }
    /// <p>A list of databases that will be available for querying.</p>
    pub fn get_databases(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::KxDatabaseConfiguration>> {
        self.inner.get_databases()
    }
    ///
    /// Appends an item to `cacheStorageConfigurations`.
    ///
    /// To override the contents of this collection use [`set_cache_storage_configurations`](Self::set_cache_storage_configurations).
    ///
    /// <p>The configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store.</p>
    pub fn cache_storage_configurations(mut self, input: crate::types::KxCacheStorageConfiguration) -> Self {
        self.inner = self.inner.cache_storage_configurations(input);
        self
    }
    /// <p>The configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store.</p>
    pub fn set_cache_storage_configurations(
        mut self,
        input: ::std::option::Option<::std::vec::Vec<crate::types::KxCacheStorageConfiguration>>,
    ) -> Self {
        self.inner = self.inner.set_cache_storage_configurations(input);
        self
    }
    /// <p>The configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store.</p>
    pub fn get_cache_storage_configurations(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::KxCacheStorageConfiguration>> {
        self.inner.get_cache_storage_configurations()
    }
    /// <p>The configuration based on which FinSpace will scale in or scale out nodes in your cluster.</p>
    pub fn auto_scaling_configuration(mut self, input: crate::types::AutoScalingConfiguration) -> Self {
        self.inner = self.inner.auto_scaling_configuration(input);
        self
    }
    /// <p>The configuration based on which FinSpace will scale in or scale out nodes in your cluster.</p>
    pub fn set_auto_scaling_configuration(mut self, input: ::std::option::Option<crate::types::AutoScalingConfiguration>) -> Self {
        self.inner = self.inner.set_auto_scaling_configuration(input);
        self
    }
    /// <p>The configuration based on which FinSpace will scale in or scale out nodes in your cluster.</p>
    pub fn get_auto_scaling_configuration(&self) -> &::std::option::Option<crate::types::AutoScalingConfiguration> {
        self.inner.get_auto_scaling_configuration()
    }
    /// <p>A description of the cluster.</p>
    pub fn cluster_description(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.cluster_description(input.into());
        self
    }
    /// <p>A description of the cluster.</p>
    pub fn set_cluster_description(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_cluster_description(input);
        self
    }
    /// <p>A description of the cluster.</p>
    pub fn get_cluster_description(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_cluster_description()
    }
    /// <p>A structure for the metadata of a cluster. It includes information like the CPUs needed, memory of instances, and number of instances.</p>
    pub fn capacity_configuration(mut self, input: crate::types::CapacityConfiguration) -> Self {
        self.inner = self.inner.capacity_configuration(input);
        self
    }
    /// <p>A structure for the metadata of a cluster. It includes information like the CPUs needed, memory of instances, and number of instances.</p>
    pub fn set_capacity_configuration(mut self, input: ::std::option::Option<crate::types::CapacityConfiguration>) -> Self {
        self.inner = self.inner.set_capacity_configuration(input);
        self
    }
    /// <p>A structure for the metadata of a cluster. It includes information like the CPUs needed, memory of instances, and number of instances.</p>
    pub fn get_capacity_configuration(&self) -> &::std::option::Option<crate::types::CapacityConfiguration> {
        self.inner.get_capacity_configuration()
    }
    /// <p>The version of FinSpace managed kdb to run.</p>
    pub fn release_label(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.release_label(input.into());
        self
    }
    /// <p>The version of FinSpace managed kdb to run.</p>
    pub fn set_release_label(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_release_label(input);
        self
    }
    /// <p>The version of FinSpace managed kdb to run.</p>
    pub fn get_release_label(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_release_label()
    }
    /// <p>Configuration details about the network where the Privatelink endpoint of the cluster resides.</p>
    pub fn vpc_configuration(mut self, input: crate::types::VpcConfiguration) -> Self {
        self.inner = self.inner.vpc_configuration(input);
        self
    }
    /// <p>Configuration details about the network where the Privatelink endpoint of the cluster resides.</p>
    pub fn set_vpc_configuration(mut self, input: ::std::option::Option<crate::types::VpcConfiguration>) -> Self {
        self.inner = self.inner.set_vpc_configuration(input);
        self
    }
    /// <p>Configuration details about the network where the Privatelink endpoint of the cluster resides.</p>
    pub fn get_vpc_configuration(&self) -> &::std::option::Option<crate::types::VpcConfiguration> {
        self.inner.get_vpc_configuration()
    }
    /// <p>Specifies a Q program that will be run at launch of a cluster. It is a relative path within <i>.zip</i> file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, <code>somedir/init.q</code>.</p>
    pub fn initialization_script(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.initialization_script(input.into());
        self
    }
    /// <p>Specifies a Q program that will be run at launch of a cluster. It is a relative path within <i>.zip</i> file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, <code>somedir/init.q</code>.</p>
    pub fn set_initialization_script(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_initialization_script(input);
        self
    }
    /// <p>Specifies a Q program that will be run at launch of a cluster. It is a relative path within <i>.zip</i> file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, <code>somedir/init.q</code>.</p>
    pub fn get_initialization_script(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_initialization_script()
    }
    ///
    /// Appends an item to `commandLineArguments`.
    ///
    /// To override the contents of this collection use [`set_command_line_arguments`](Self::set_command_line_arguments).
    ///
    /// <p>Defines the key-value pairs to make them available inside the cluster.</p>
    pub fn command_line_arguments(mut self, input: crate::types::KxCommandLineArgument) -> Self {
        self.inner = self.inner.command_line_arguments(input);
        self
    }
    /// <p>Defines the key-value pairs to make them available inside the cluster.</p>
    pub fn set_command_line_arguments(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::KxCommandLineArgument>>) -> Self {
        self.inner = self.inner.set_command_line_arguments(input);
        self
    }
    /// <p>Defines the key-value pairs to make them available inside the cluster.</p>
    pub fn get_command_line_arguments(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::KxCommandLineArgument>> {
        self.inner.get_command_line_arguments()
    }
    /// <p>The details of the custom code that you want to use inside a cluster when analyzing a data. It consists of the S3 source bucket, location, S3 object version, and the relative path from where the custom code is loaded into the cluster.</p>
    pub fn code(mut self, input: crate::types::CodeConfiguration) -> Self {
        self.inner = self.inner.code(input);
        self
    }
    /// <p>The details of the custom code that you want to use inside a cluster when analyzing a data. It consists of the S3 source bucket, location, S3 object version, and the relative path from where the custom code is loaded into the cluster.</p>
    pub fn set_code(mut self, input: ::std::option::Option<crate::types::CodeConfiguration>) -> Self {
        self.inner = self.inner.set_code(input);
        self
    }
    /// <p>The details of the custom code that you want to use inside a cluster when analyzing a data. It consists of the S3 source bucket, location, S3 object version, and the relative path from where the custom code is loaded into the cluster.</p>
    pub fn get_code(&self) -> &::std::option::Option<crate::types::CodeConfiguration> {
        self.inner.get_code()
    }
    /// <p>An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.</p>
    pub fn execution_role(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.execution_role(input.into());
        self
    }
    /// <p>An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.</p>
    pub fn set_execution_role(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_execution_role(input);
        self
    }
    /// <p>An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.</p>
    pub fn get_execution_role(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_execution_role()
    }
    /// <p>The size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose <code>clusterType</code> as RDB. All the data written to this storage space is lost when the cluster node is restarted.</p>
    pub fn savedown_storage_configuration(mut self, input: crate::types::KxSavedownStorageConfiguration) -> Self {
        self.inner = self.inner.savedown_storage_configuration(input);
        self
    }
    /// <p>The size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose <code>clusterType</code> as RDB. All the data written to this storage space is lost when the cluster node is restarted.</p>
    pub fn set_savedown_storage_configuration(mut self, input: ::std::option::Option<crate::types::KxSavedownStorageConfiguration>) -> Self {
        self.inner = self.inner.set_savedown_storage_configuration(input);
        self
    }
    /// <p>The size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose <code>clusterType</code> as RDB. All the data written to this storage space is lost when the cluster node is restarted.</p>
    pub fn get_savedown_storage_configuration(&self) -> &::std::option::Option<crate::types::KxSavedownStorageConfiguration> {
        self.inner.get_savedown_storage_configuration()
    }
    /// <p>The number of availability zones you want to assign per cluster. This can be one of the following</p>
    /// <ul>
    /// <li>
    /// <p><code>SINGLE</code> – Assigns one availability zone per cluster.</p></li>
    /// <li>
    /// <p><code>MULTI</code> – Assigns all the availability zones per cluster.</p></li>
    /// </ul>
    pub fn az_mode(mut self, input: crate::types::KxAzMode) -> Self {
        self.inner = self.inner.az_mode(input);
        self
    }
    /// <p>The number of availability zones you want to assign per cluster. This can be one of the following</p>
    /// <ul>
    /// <li>
    /// <p><code>SINGLE</code> – Assigns one availability zone per cluster.</p></li>
    /// <li>
    /// <p><code>MULTI</code> – Assigns all the availability zones per cluster.</p></li>
    /// </ul>
    pub fn set_az_mode(mut self, input: ::std::option::Option<crate::types::KxAzMode>) -> Self {
        self.inner = self.inner.set_az_mode(input);
        self
    }
    /// <p>The number of availability zones you want to assign per cluster. This can be one of the following</p>
    /// <ul>
    /// <li>
    /// <p><code>SINGLE</code> – Assigns one availability zone per cluster.</p></li>
    /// <li>
    /// <p><code>MULTI</code> – Assigns all the availability zones per cluster.</p></li>
    /// </ul>
    pub fn get_az_mode(&self) -> &::std::option::Option<crate::types::KxAzMode> {
        self.inner.get_az_mode()
    }
    /// <p>The availability zone identifiers for the requested regions.</p>
    pub fn availability_zone_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.availability_zone_id(input.into());
        self
    }
    /// <p>The availability zone identifiers for the requested regions.</p>
    pub fn set_availability_zone_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        self.inner = self.inner.set_availability_zone_id(input);
        self
    }
    /// <p>The availability zone identifiers for the requested regions.</p>
    pub fn get_availability_zone_id(&self) -> &::std::option::Option<::std::string::String> {
        self.inner.get_availability_zone_id()
    }
    ///
    /// Adds a key-value pair to `tags`.
    ///
    /// To override the contents of this collection use [`set_tags`](Self::set_tags).
    ///
    /// <p>A list of key-value pairs to label the cluster. You can add up to 50 tags to a cluster.</p>
    pub fn tags(mut self, k: impl ::std::convert::Into<::std::string::String>, v: impl ::std::convert::Into<::std::string::String>) -> Self {
        self.inner = self.inner.tags(k.into(), v.into());
        self
    }
    /// <p>A list of key-value pairs to label the cluster. You can add up to 50 tags to a cluster.</p>
    pub fn set_tags(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>) -> Self {
        self.inner = self.inner.set_tags(input);
        self
    }
    /// <p>A list of key-value pairs to label the cluster. You can add up to 50 tags to a cluster.</p>
    pub fn get_tags(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>> {
        self.inner.get_tags()
    }
    /// <p>The structure that stores the configuration details of a scaling group.</p>
    pub fn scaling_group_configuration(mut self, input: crate::types::KxScalingGroupConfiguration) -> Self {
        self.inner = self.inner.scaling_group_configuration(input);
        self
    }
    /// <p>The structure that stores the configuration details of a scaling group.</p>
    pub fn set_scaling_group_configuration(mut self, input: ::std::option::Option<crate::types::KxScalingGroupConfiguration>) -> Self {
        self.inner = self.inner.set_scaling_group_configuration(input);
        self
    }
    /// <p>The structure that stores the configuration details of a scaling group.</p>
    pub fn get_scaling_group_configuration(&self) -> &::std::option::Option<crate::types::KxScalingGroupConfiguration> {
        self.inner.get_scaling_group_configuration()
    }
}