# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
from . import _utilities, _tables

__all__ = [
    'CloudCredentialAmazonec2CredentialConfigArgs',
    'CloudCredentialAzureCredentialConfigArgs',
    'CloudCredentialDigitaloceanCredentialConfigArgs',
    'CloudCredentialLinodeCredentialConfigArgs',
    'CloudCredentialOpenstackCredentialConfigArgs',
    'CloudCredentialVsphereCredentialConfigArgs',
    'ClusterAksConfigArgs',
    'ClusterAlertGroupRecipientArgs',
    'ClusterAlertRuleEventRuleArgs',
    'ClusterAlertRuleMetricRuleArgs',
    'ClusterAlertRuleNodeRuleArgs',
    'ClusterAlertRuleSystemServiceRuleArgs',
    'ClusterAlterGroupRecipientArgs',
    'ClusterAlterRuleEventRuleArgs',
    'ClusterAlterRuleMetricRuleArgs',
    'ClusterAlterRuleNodeRuleArgs',
    'ClusterAlterRuleSystemServiceRuleArgs',
    'ClusterClusterAuthEndpointArgs',
    'ClusterClusterMonitoringInputArgs',
    'ClusterClusterRegistrationTokenArgs',
    'ClusterClusterTemplateAnswersArgs',
    'ClusterClusterTemplateQuestionArgs',
    'ClusterEksConfigArgs',
    'ClusterGkeConfigArgs',
    'ClusterK3sConfigArgs',
    'ClusterK3sConfigUpgradeStrategyArgs',
    'ClusterLoggingCustomTargetConfigArgs',
    'ClusterLoggingElasticsearchConfigArgs',
    'ClusterLoggingFluentdConfigArgs',
    'ClusterLoggingFluentdConfigFluentServerArgs',
    'ClusterLoggingKafkaConfigArgs',
    'ClusterLoggingSplunkConfigArgs',
    'ClusterLoggingSyslogConfigArgs',
    'ClusterRkeConfigArgs',
    'ClusterRkeConfigAuthenticationArgs',
    'ClusterRkeConfigAuthorizationArgs',
    'ClusterRkeConfigBastionHostArgs',
    'ClusterRkeConfigCloudProviderArgs',
    'ClusterRkeConfigCloudProviderAwsCloudProviderArgs',
    'ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs',
    'ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs',
    'ClusterRkeConfigCloudProviderAzureCloudProviderArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs',
    'ClusterRkeConfigDnsArgs',
    'ClusterRkeConfigDnsNodelocalArgs',
    'ClusterRkeConfigIngressArgs',
    'ClusterRkeConfigMonitoringArgs',
    'ClusterRkeConfigMonitoringUpdateStrategyArgs',
    'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs',
    'ClusterRkeConfigNetworkArgs',
    'ClusterRkeConfigNetworkCalicoNetworkProviderArgs',
    'ClusterRkeConfigNetworkCanalNetworkProviderArgs',
    'ClusterRkeConfigNetworkFlannelNetworkProviderArgs',
    'ClusterRkeConfigNetworkWeaveNetworkProviderArgs',
    'ClusterRkeConfigNodeArgs',
    'ClusterRkeConfigPrivateRegistryArgs',
    'ClusterRkeConfigServicesArgs',
    'ClusterRkeConfigServicesEtcdArgs',
    'ClusterRkeConfigServicesEtcdBackupConfigArgs',
    'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs',
    'ClusterRkeConfigServicesKubeApiArgs',
    'ClusterRkeConfigServicesKubeApiAuditLogArgs',
    'ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs',
    'ClusterRkeConfigServicesKubeApiEventRateLimitArgs',
    'ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs',
    'ClusterRkeConfigServicesKubeControllerArgs',
    'ClusterRkeConfigServicesKubeletArgs',
    'ClusterRkeConfigServicesKubeproxyArgs',
    'ClusterRkeConfigServicesSchedulerArgs',
    'ClusterRkeConfigUpgradeStrategyArgs',
    'ClusterRkeConfigUpgradeStrategyDrainInputArgs',
    'ClusterScheduledClusterScanArgs',
    'ClusterScheduledClusterScanScanConfigArgs',
    'ClusterScheduledClusterScanScanConfigCisScanConfigArgs',
    'ClusterScheduledClusterScanScheduleConfigArgs',
    'ClusterTemplateMemberArgs',
    'ClusterTemplateTemplateRevisionArgs',
    'ClusterTemplateTemplateRevisionClusterConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputArgs',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigArgs',
    'ClusterTemplateTemplateRevisionQuestionArgs',
    'EtcdBackupBackupConfigArgs',
    'EtcdBackupBackupConfigS3BackupConfigArgs',
    'MultiClusterAppAnswerArgs',
    'MultiClusterAppMemberArgs',
    'MultiClusterAppTargetArgs',
    'MultiClusterAppUpgradeStrategyArgs',
    'MultiClusterAppUpgradeStrategyRollingUpdateArgs',
    'NamespaceContainerResourceLimitArgs',
    'NamespaceResourceQuotaArgs',
    'NamespaceResourceQuotaLimitArgs',
    'NodePoolNodeTaintArgs',
    'NodeTemplateAmazonec2ConfigArgs',
    'NodeTemplateAzureConfigArgs',
    'NodeTemplateDigitaloceanConfigArgs',
    'NodeTemplateLinodeConfigArgs',
    'NodeTemplateOpennebulaConfigArgs',
    'NodeTemplateOpenstackConfigArgs',
    'NodeTemplateVsphereConfigArgs',
    'NotifierPagerdutyConfigArgs',
    'NotifierSlackConfigArgs',
    'NotifierSmtpConfigArgs',
    'NotifierWebhookConfigArgs',
    'NotifierWechatConfigArgs',
    'PodSecurityPolicyTemplateAllowedCsiDriverArgs',
    'PodSecurityPolicyTemplateAllowedFlexVolumeArgs',
    'PodSecurityPolicyTemplateAllowedHostPathArgs',
    'PodSecurityPolicyTemplateFsGroupArgs',
    'PodSecurityPolicyTemplateFsGroupRangeArgs',
    'PodSecurityPolicyTemplateHostPortArgs',
    'PodSecurityPolicyTemplateRunAsGroupArgs',
    'PodSecurityPolicyTemplateRunAsGroupRangeArgs',
    'PodSecurityPolicyTemplateRunAsUserArgs',
    'PodSecurityPolicyTemplateRunAsUserRangeArgs',
    'PodSecurityPolicyTemplateRuntimeClassArgs',
    'PodSecurityPolicyTemplateSeLinuxArgs',
    'PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs',
    'PodSecurityPolicyTemplateSupplementalGroupArgs',
    'PodSecurityPolicyTemplateSupplementalGroupRangeArgs',
    'ProjectAlertGroupRecipientArgs',
    'ProjectAlertRuleMetricRuleArgs',
    'ProjectAlertRulePodRuleArgs',
    'ProjectAlertRuleWorkloadRuleArgs',
    'ProjectContainerResourceLimitArgs',
    'ProjectLoggingCustomTargetConfigArgs',
    'ProjectLoggingElasticsearchConfigArgs',
    'ProjectLoggingFluentdConfigArgs',
    'ProjectLoggingFluentdConfigFluentServerArgs',
    'ProjectLoggingKafkaConfigArgs',
    'ProjectLoggingSplunkConfigArgs',
    'ProjectLoggingSyslogConfigArgs',
    'ProjectProjectMonitoringInputArgs',
    'ProjectResourceQuotaArgs',
    'ProjectResourceQuotaNamespaceDefaultLimitArgs',
    'ProjectResourceQuotaProjectLimitArgs',
    'RegistryRegistryArgs',
    'RoleTempalteRuleArgs',
    'GetPodSecurityPolicyTemplateAllowedCsiDriverArgs',
    'GetPodSecurityPolicyTemplateAllowedFlexVolumeArgs',
    'GetPodSecurityPolicyTemplateAllowedHostPathArgs',
    'GetPodSecurityPolicyTemplateFsGroupArgs',
    'GetPodSecurityPolicyTemplateFsGroupRangeArgs',
    'GetPodSecurityPolicyTemplateHostPortArgs',
    'GetPodSecurityPolicyTemplateRunAsGroupArgs',
    'GetPodSecurityPolicyTemplateRunAsGroupRangeArgs',
    'GetPodSecurityPolicyTemplateRunAsUserArgs',
    'GetPodSecurityPolicyTemplateRunAsUserRangeArgs',
    'GetPodSecurityPolicyTemplateRuntimeClassArgs',
    'GetPodSecurityPolicyTemplateSeLinuxArgs',
    'GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs',
    'GetPodSecurityPolicyTemplateSupplementalGroupArgs',
    'GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs',
]

@pulumi.input_type
class CloudCredentialAmazonec2CredentialConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 secret_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] access_key: AWS access key (string)
        :param pulumi.Input[str] secret_key: AWS secret key (string)
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        AWS access key (string)
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[str]:
        """
        AWS secret key (string)
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_key", value)


@pulumi.input_type
class CloudCredentialAzureCredentialConfigArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 subscription_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] client_id: Azure Service Principal Account ID (string)
        :param pulumi.Input[str] client_secret: Azure Service Principal Account password (string)
        :param pulumi.Input[str] subscription_id: Azure Subscription ID (string)
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[str]:
        """
        Azure Service Principal Account ID (string)
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[str]:
        """
        Azure Service Principal Account password (string)
        """
        return pulumi.get(self, "client_secret")

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> pulumi.Input[str]:
        """
        Azure Subscription ID (string)
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "subscription_id", value)


@pulumi.input_type
class CloudCredentialDigitaloceanCredentialConfigArgs:
    def __init__(__self__, *,
                 access_token: pulumi.Input[str]):
        """
        :param pulumi.Input[str] access_token: DigitalOcean access token (string)
        """
        pulumi.set(__self__, "access_token", access_token)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> pulumi.Input[str]:
        """
        DigitalOcean access token (string)
        """
        return pulumi.get(self, "access_token")

    @access_token.setter
    def access_token(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_token", value)


@pulumi.input_type
class CloudCredentialLinodeCredentialConfigArgs:
    def __init__(__self__, *,
                 token: pulumi.Input[str]):
        """
        :param pulumi.Input[str] token: Linode API token (string)
        """
        pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter
    def token(self) -> pulumi.Input[str]:
        """
        Linode API token (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: pulumi.Input[str]):
        pulumi.set(self, "token", value)


@pulumi.input_type
class CloudCredentialOpenstackCredentialConfigArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: vSphere password (string)
        """
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        vSphere password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)


@pulumi.input_type
class CloudCredentialVsphereCredentialConfigArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str],
                 vcenter: pulumi.Input[str],
                 vcenter_port: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] password: vSphere password (string)
        :param pulumi.Input[str] username: vSphere username (string)
        :param pulumi.Input[str] vcenter: vSphere IP/hostname for vCenter (string)
        :param pulumi.Input[str] vcenter_port: vSphere Port for vCenter. Default `443` (string)
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vcenter", vcenter)
        if vcenter_port is not None:
            pulumi.set(__self__, "vcenter_port", vcenter_port)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        vSphere password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        vSphere username (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter
    def vcenter(self) -> pulumi.Input[str]:
        """
        vSphere IP/hostname for vCenter (string)
        """
        return pulumi.get(self, "vcenter")

    @vcenter.setter
    def vcenter(self, value: pulumi.Input[str]):
        pulumi.set(self, "vcenter", value)

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere Port for vCenter. Default `443` (string)
        """
        return pulumi.get(self, "vcenter_port")

    @vcenter_port.setter
    def vcenter_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vcenter_port", value)


@pulumi.input_type
class ClusterAksConfigArgs:
    def __init__(__self__, *,
                 agent_dns_prefix: pulumi.Input[str],
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 kubernetes_version: pulumi.Input[str],
                 master_dns_prefix: pulumi.Input[str],
                 resource_group: pulumi.Input[str],
                 ssh_public_key_contents: pulumi.Input[str],
                 subnet: pulumi.Input[str],
                 subscription_id: pulumi.Input[str],
                 tenant_id: pulumi.Input[str],
                 virtual_network: pulumi.Input[str],
                 virtual_network_resource_group: pulumi.Input[str],
                 aad_server_app_secret: Optional[pulumi.Input[str]] = None,
                 aad_tenant_id: Optional[pulumi.Input[str]] = None,
                 add_client_app_id: Optional[pulumi.Input[str]] = None,
                 add_server_app_id: Optional[pulumi.Input[str]] = None,
                 admin_username: Optional[pulumi.Input[str]] = None,
                 agent_os_disk_size: Optional[pulumi.Input[float]] = None,
                 agent_pool_name: Optional[pulumi.Input[str]] = None,
                 agent_storage_profile: Optional[pulumi.Input[str]] = None,
                 agent_vm_size: Optional[pulumi.Input[str]] = None,
                 auth_base_url: Optional[pulumi.Input[str]] = None,
                 base_url: Optional[pulumi.Input[str]] = None,
                 count: Optional[pulumi.Input[float]] = None,
                 dns_service_ip: Optional[pulumi.Input[str]] = None,
                 docker_bridge_cidr: Optional[pulumi.Input[str]] = None,
                 enable_http_application_routing: Optional[pulumi.Input[bool]] = None,
                 enable_monitoring: Optional[pulumi.Input[bool]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 log_analytics_workspace: Optional[pulumi.Input[str]] = None,
                 log_analytics_workspace_resource_group: Optional[pulumi.Input[str]] = None,
                 max_pods: Optional[pulumi.Input[float]] = None,
                 network_plugin: Optional[pulumi.Input[str]] = None,
                 network_policy: Optional[pulumi.Input[str]] = None,
                 pod_cidr: Optional[pulumi.Input[str]] = None,
                 service_cidr: Optional[pulumi.Input[str]] = None,
                 tag: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] agent_dns_prefix: DNS prefix to be used to create the FQDN for the agent pool (string)
        :param pulumi.Input[str] client_id: Azure client ID to use (string)
        :param pulumi.Input[str] client_secret: Azure client secret associated with the \"client id\" (string)
        :param pulumi.Input[str] kubernetes_version: The Kubernetes master version (string)
        :param pulumi.Input[str] master_dns_prefix: DNS prefix to use the Kubernetes cluster control pane (string)
        :param pulumi.Input[str] resource_group: The name of the Cluster resource group (string)
        :param pulumi.Input[str] ssh_public_key_contents: Contents of the SSH public key used to authenticate with Linux hosts (string)
        :param pulumi.Input[str] subnet: The name of an existing Azure Virtual Subnet. Composite of agent virtual network subnet ID (string)
        :param pulumi.Input[str] subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription (string)
        :param pulumi.Input[str] tenant_id: Azure tenant ID to use (string)
        :param pulumi.Input[str] virtual_network: The name of the virtual network to use. If it's not specified Rancher will create a new VPC (string)
        :param pulumi.Input[str] virtual_network_resource_group: The resource group of an existing Azure Virtual Network. Composite of agent virtual network subnet ID (string)
        :param pulumi.Input[str] aad_server_app_secret: The secret of an Azure Active Directory server application (string)
        :param pulumi.Input[str] aad_tenant_id: The ID of an Azure Active Directory tenant (string)
        :param pulumi.Input[str] add_client_app_id: The ID of an Azure Active Directory client application of type \"Native\". This application is for user login via kubectl (string)
        :param pulumi.Input[str] add_server_app_id: The ID of an Azure Active Directory server application of type \"Web app/API\". This application represents the managed cluster's apiserver (Server application) (string)
        :param pulumi.Input[str] admin_username: The administrator username to use for Linux hosts. Default `azureuser` (string)
        :param pulumi.Input[float] agent_os_disk_size: GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the \"agent vm size\" specified. Default `0` (int)
        :param pulumi.Input[str] agent_pool_name: Name for the agent pool, upto 12 alphanumeric characters. Default `agentpool0` (string)
        :param pulumi.Input[str] agent_storage_profile: Storage profile specifies what kind of storage used on machine in the agent pool. Chooses from [ManagedDisks StorageAccount]. Default `ManagedDisks` (string)
        :param pulumi.Input[str] agent_vm_size: Size of machine in the agent pool. Default `Standard_D1_v2` (string)
        :param pulumi.Input[str] auth_base_url: Different authentication API url to use. Default `https://login.microsoftonline.com/` (string)
        :param pulumi.Input[str] base_url: Different resource management API url to use. Default `https://management.azure.com/` (string)
        :param pulumi.Input[float] count: Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive). Default `1` (int)
        :param pulumi.Input[str] dns_service_ip: An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes Service address range specified in \"service cidr\". Default `10.0.0.10` (string)
        :param pulumi.Input[str] docker_bridge_cidr: A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes Service address range specified in \"service cidr\". Default `172.17.0.1/16` (string)
        :param pulumi.Input[bool] enable_http_application_routing: Enable the Kubernetes ingress with automatic public DNS name creation. Default `false` (bool)
        :param pulumi.Input[bool] enable_monitoring: Turn on Azure Log Analytics monitoring. Uses the Log Analytics \"Default\" workspace if it exists, else creates one. if using an existing workspace, specifies \"log analytics workspace resource id\". Default `true` (bool)
        :param pulumi.Input[str] location: Azure Kubernetes cluster location. Default `eastus` (string)
        :param pulumi.Input[str] log_analytics_workspace: The name of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses '{resource group}-{subscription id}-{location code}' (string)
        :param pulumi.Input[str] log_analytics_workspace_resource_group: The resource group of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses the 'Cluster' resource group (string)
        :param pulumi.Input[float] max_pods: Maximum number of pods that can run on a node. Default `110` (int)
        :param pulumi.Input[str] network_plugin: Network plugin used for building Kubernetes network. Chooses from `azure` or `kubenet`. Default `azure` (string)
        :param pulumi.Input[str] network_policy: Network policy used for building Kubernetes network. Chooses from `calico` (string)
        :param pulumi.Input[str] pod_cidr: A CIDR notation IP range from which to assign Kubernetes Pod IPs when \"network plugin\" is specified in \"kubenet\". Default `172.244.0.0/16` (string)
        :param pulumi.Input[str] service_cidr: A CIDR notation IP range from which to assign Kubernetes Service cluster IPs. It must not overlap with any Subnet IP ranges. Default `10.0.0.0/16` (string)
        :param pulumi.Input[Mapping[str, Any]] tag: Tags for Kubernetes cluster. For example, foo=bar (map)
        """
        pulumi.set(__self__, "agent_dns_prefix", agent_dns_prefix)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "master_dns_prefix", master_dns_prefix)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "ssh_public_key_contents", ssh_public_key_contents)
        pulumi.set(__self__, "subnet", subnet)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "virtual_network", virtual_network)
        pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)
        if aad_server_app_secret is not None:
            pulumi.set(__self__, "aad_server_app_secret", aad_server_app_secret)
        if aad_tenant_id is not None:
            pulumi.set(__self__, "aad_tenant_id", aad_tenant_id)
        if add_client_app_id is not None:
            pulumi.set(__self__, "add_client_app_id", add_client_app_id)
        if add_server_app_id is not None:
            pulumi.set(__self__, "add_server_app_id", add_server_app_id)
        if admin_username is not None:
            pulumi.set(__self__, "admin_username", admin_username)
        if agent_os_disk_size is not None:
            pulumi.set(__self__, "agent_os_disk_size", agent_os_disk_size)
        if agent_pool_name is not None:
            pulumi.set(__self__, "agent_pool_name", agent_pool_name)
        if agent_storage_profile is not None:
            pulumi.set(__self__, "agent_storage_profile", agent_storage_profile)
        if agent_vm_size is not None:
            pulumi.set(__self__, "agent_vm_size", agent_vm_size)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if dns_service_ip is not None:
            pulumi.set(__self__, "dns_service_ip", dns_service_ip)
        if docker_bridge_cidr is not None:
            pulumi.set(__self__, "docker_bridge_cidr", docker_bridge_cidr)
        if enable_http_application_routing is not None:
            pulumi.set(__self__, "enable_http_application_routing", enable_http_application_routing)
        if enable_monitoring is not None:
            pulumi.set(__self__, "enable_monitoring", enable_monitoring)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if log_analytics_workspace is not None:
            pulumi.set(__self__, "log_analytics_workspace", log_analytics_workspace)
        if log_analytics_workspace_resource_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_resource_group", log_analytics_workspace_resource_group)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter(name="agentDnsPrefix")
    def agent_dns_prefix(self) -> pulumi.Input[str]:
        """
        DNS prefix to be used to create the FQDN for the agent pool (string)
        """
        return pulumi.get(self, "agent_dns_prefix")

    @agent_dns_prefix.setter
    def agent_dns_prefix(self, value: pulumi.Input[str]):
        pulumi.set(self, "agent_dns_prefix", value)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[str]:
        """
        Azure client ID to use (string)
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[str]:
        """
        Azure client secret associated with the \"client id\" (string)
        """
        return pulumi.get(self, "client_secret")

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> pulumi.Input[str]:
        """
        The Kubernetes master version (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @kubernetes_version.setter
    def kubernetes_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "kubernetes_version", value)

    @property
    @pulumi.getter(name="masterDnsPrefix")
    def master_dns_prefix(self) -> pulumi.Input[str]:
        """
        DNS prefix to use the Kubernetes cluster control pane (string)
        """
        return pulumi.get(self, "master_dns_prefix")

    @master_dns_prefix.setter
    def master_dns_prefix(self, value: pulumi.Input[str]):
        pulumi.set(self, "master_dns_prefix", value)

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> pulumi.Input[str]:
        """
        The name of the Cluster resource group (string)
        """
        return pulumi.get(self, "resource_group")

    @resource_group.setter
    def resource_group(self, value: pulumi.Input[str]):
        pulumi.set(self, "resource_group", value)

    @property
    @pulumi.getter(name="sshPublicKeyContents")
    def ssh_public_key_contents(self) -> pulumi.Input[str]:
        """
        Contents of the SSH public key used to authenticate with Linux hosts (string)
        """
        return pulumi.get(self, "ssh_public_key_contents")

    @ssh_public_key_contents.setter
    def ssh_public_key_contents(self, value: pulumi.Input[str]):
        pulumi.set(self, "ssh_public_key_contents", value)

    @property
    @pulumi.getter
    def subnet(self) -> pulumi.Input[str]:
        """
        The name of an existing Azure Virtual Subnet. Composite of agent virtual network subnet ID (string)
        """
        return pulumi.get(self, "subnet")

    @subnet.setter
    def subnet(self, value: pulumi.Input[str]):
        pulumi.set(self, "subnet", value)

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> pulumi.Input[str]:
        """
        Subscription credentials which uniquely identify Microsoft Azure subscription (string)
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "subscription_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> pulumi.Input[str]:
        """
        Azure tenant ID to use (string)
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "tenant_id", value)

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> pulumi.Input[str]:
        """
        The name of the virtual network to use. If it's not specified Rancher will create a new VPC (string)
        """
        return pulumi.get(self, "virtual_network")

    @virtual_network.setter
    def virtual_network(self, value: pulumi.Input[str]):
        pulumi.set(self, "virtual_network", value)

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> pulumi.Input[str]:
        """
        The resource group of an existing Azure Virtual Network. Composite of agent virtual network subnet ID (string)
        """
        return pulumi.get(self, "virtual_network_resource_group")

    @virtual_network_resource_group.setter
    def virtual_network_resource_group(self, value: pulumi.Input[str]):
        pulumi.set(self, "virtual_network_resource_group", value)

    @property
    @pulumi.getter(name="aadServerAppSecret")
    def aad_server_app_secret(self) -> Optional[pulumi.Input[str]]:
        """
        The secret of an Azure Active Directory server application (string)
        """
        return pulumi.get(self, "aad_server_app_secret")

    @aad_server_app_secret.setter
    def aad_server_app_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aad_server_app_secret", value)

    @property
    @pulumi.getter(name="aadTenantId")
    def aad_tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an Azure Active Directory tenant (string)
        """
        return pulumi.get(self, "aad_tenant_id")

    @aad_tenant_id.setter
    def aad_tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aad_tenant_id", value)

    @property
    @pulumi.getter(name="addClientAppId")
    def add_client_app_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an Azure Active Directory client application of type \"Native\". This application is for user login via kubectl (string)
        """
        return pulumi.get(self, "add_client_app_id")

    @add_client_app_id.setter
    def add_client_app_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "add_client_app_id", value)

    @property
    @pulumi.getter(name="addServerAppId")
    def add_server_app_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an Azure Active Directory server application of type \"Web app/API\". This application represents the managed cluster's apiserver (Server application) (string)
        """
        return pulumi.get(self, "add_server_app_id")

    @add_server_app_id.setter
    def add_server_app_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "add_server_app_id", value)

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> Optional[pulumi.Input[str]]:
        """
        The administrator username to use for Linux hosts. Default `azureuser` (string)
        """
        return pulumi.get(self, "admin_username")

    @admin_username.setter
    def admin_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "admin_username", value)

    @property
    @pulumi.getter(name="agentOsDiskSize")
    def agent_os_disk_size(self) -> Optional[pulumi.Input[float]]:
        """
        GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the \"agent vm size\" specified. Default `0` (int)
        """
        return pulumi.get(self, "agent_os_disk_size")

    @agent_os_disk_size.setter
    def agent_os_disk_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "agent_os_disk_size", value)

    @property
    @pulumi.getter(name="agentPoolName")
    def agent_pool_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name for the agent pool, upto 12 alphanumeric characters. Default `agentpool0` (string)
        """
        return pulumi.get(self, "agent_pool_name")

    @agent_pool_name.setter
    def agent_pool_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "agent_pool_name", value)

    @property
    @pulumi.getter(name="agentStorageProfile")
    def agent_storage_profile(self) -> Optional[pulumi.Input[str]]:
        """
        Storage profile specifies what kind of storage used on machine in the agent pool. Chooses from [ManagedDisks StorageAccount]. Default `ManagedDisks` (string)
        """
        return pulumi.get(self, "agent_storage_profile")

    @agent_storage_profile.setter
    def agent_storage_profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "agent_storage_profile", value)

    @property
    @pulumi.getter(name="agentVmSize")
    def agent_vm_size(self) -> Optional[pulumi.Input[str]]:
        """
        Size of machine in the agent pool. Default `Standard_D1_v2` (string)
        """
        return pulumi.get(self, "agent_vm_size")

    @agent_vm_size.setter
    def agent_vm_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "agent_vm_size", value)

    @property
    @pulumi.getter(name="authBaseUrl")
    def auth_base_url(self) -> Optional[pulumi.Input[str]]:
        """
        Different authentication API url to use. Default `https://login.microsoftonline.com/` (string)
        """
        return pulumi.get(self, "auth_base_url")

    @auth_base_url.setter
    def auth_base_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_base_url", value)

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[pulumi.Input[str]]:
        """
        Different resource management API url to use. Default `https://management.azure.com/` (string)
        """
        return pulumi.get(self, "base_url")

    @base_url.setter
    def base_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "base_url", value)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[float]]:
        """
        Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive). Default `1` (int)
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter(name="dnsServiceIp")
    def dns_service_ip(self) -> Optional[pulumi.Input[str]]:
        """
        An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes Service address range specified in \"service cidr\". Default `10.0.0.10` (string)
        """
        return pulumi.get(self, "dns_service_ip")

    @dns_service_ip.setter
    def dns_service_ip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dns_service_ip", value)

    @property
    @pulumi.getter(name="dockerBridgeCidr")
    def docker_bridge_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes Service address range specified in \"service cidr\". Default `172.17.0.1/16` (string)
        """
        return pulumi.get(self, "docker_bridge_cidr")

    @docker_bridge_cidr.setter
    def docker_bridge_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_bridge_cidr", value)

    @property
    @pulumi.getter(name="enableHttpApplicationRouting")
    def enable_http_application_routing(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable the Kubernetes ingress with automatic public DNS name creation. Default `false` (bool)
        """
        return pulumi.get(self, "enable_http_application_routing")

    @enable_http_application_routing.setter
    def enable_http_application_routing(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_http_application_routing", value)

    @property
    @pulumi.getter(name="enableMonitoring")
    def enable_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Turn on Azure Log Analytics monitoring. Uses the Log Analytics \"Default\" workspace if it exists, else creates one. if using an existing workspace, specifies \"log analytics workspace resource id\". Default `true` (bool)
        """
        return pulumi.get(self, "enable_monitoring")

    @enable_monitoring.setter
    def enable_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_monitoring", value)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Kubernetes cluster location. Default `eastus` (string)
        """
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter(name="logAnalyticsWorkspace")
    def log_analytics_workspace(self) -> Optional[pulumi.Input[str]]:
        """
        The name of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses '{resource group}-{subscription id}-{location code}' (string)
        """
        return pulumi.get(self, "log_analytics_workspace")

    @log_analytics_workspace.setter
    def log_analytics_workspace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_analytics_workspace", value)

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceResourceGroup")
    def log_analytics_workspace_resource_group(self) -> Optional[pulumi.Input[str]]:
        """
        The resource group of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses the 'Cluster' resource group (string)
        """
        return pulumi.get(self, "log_analytics_workspace_resource_group")

    @log_analytics_workspace_resource_group.setter
    def log_analytics_workspace_resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_analytics_workspace_resource_group", value)

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[pulumi.Input[float]]:
        """
        Maximum number of pods that can run on a node. Default `110` (int)
        """
        return pulumi.get(self, "max_pods")

    @max_pods.setter
    def max_pods(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_pods", value)

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> Optional[pulumi.Input[str]]:
        """
        Network plugin used for building Kubernetes network. Chooses from `azure` or `kubenet`. Default `azure` (string)
        """
        return pulumi.get(self, "network_plugin")

    @network_plugin.setter
    def network_plugin(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_plugin", value)

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Network policy used for building Kubernetes network. Chooses from `calico` (string)
        """
        return pulumi.get(self, "network_policy")

    @network_policy.setter
    def network_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_policy", value)

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        A CIDR notation IP range from which to assign Kubernetes Pod IPs when \"network plugin\" is specified in \"kubenet\". Default `172.244.0.0/16` (string)
        """
        return pulumi.get(self, "pod_cidr")

    @pod_cidr.setter
    def pod_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_cidr", value)

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        A CIDR notation IP range from which to assign Kubernetes Service cluster IPs. It must not overlap with any Subnet IP ranges. Default `10.0.0.0/16` (string)
        """
        return pulumi.get(self, "service_cidr")

    @service_cidr.setter
    def service_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_cidr", value)

    @property
    @pulumi.getter
    def tag(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Tags for Kubernetes cluster. For example, foo=bar (map)
        """
        return pulumi.get(self, "tag")

    @tag.setter
    def tag(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "tag", value)


@pulumi.input_type
class ClusterAlertGroupRecipientArgs:
    def __init__(__self__, *,
                 notifier_id: pulumi.Input[str],
                 default_recipient: Optional[pulumi.Input[bool]] = None,
                 notifier_type: Optional[pulumi.Input[str]] = None,
                 recipient: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] notifier_id: Recipient notifier ID (string)
        :param pulumi.Input[bool] default_recipient: Use notifier default recipient, overriding `recipient` argument if set.  Default: `false` (bool)
        :param pulumi.Input[str] notifier_type: Recipient notifier ID. Supported values : `"pagerduty" | "slack" | "email" | "webhook" | "wechat"` (string)
        :param pulumi.Input[str] recipient: Recipient (string)
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)
        if notifier_type is not None:
            pulumi.set(__self__, "notifier_type", notifier_type)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> pulumi.Input[str]:
        """
        Recipient notifier ID (string)
        """
        return pulumi.get(self, "notifier_id")

    @notifier_id.setter
    def notifier_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "notifier_id", value)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[pulumi.Input[bool]]:
        """
        Use notifier default recipient, overriding `recipient` argument if set.  Default: `false` (bool)
        """
        return pulumi.get(self, "default_recipient")

    @default_recipient.setter
    def default_recipient(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "default_recipient", value)

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> Optional[pulumi.Input[str]]:
        """
        Recipient notifier ID. Supported values : `"pagerduty" | "slack" | "email" | "webhook" | "wechat"` (string)
        """
        return pulumi.get(self, "notifier_type")

    @notifier_type.setter
    def notifier_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "notifier_type", value)

    @property
    @pulumi.getter
    def recipient(self) -> Optional[pulumi.Input[str]]:
        """
        Recipient (string)
        """
        return pulumi.get(self, "recipient")

    @recipient.setter
    def recipient(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recipient", value)


@pulumi.input_type
class ClusterAlertRuleEventRuleArgs:
    def __init__(__self__, *,
                 resource_kind: pulumi.Input[str],
                 event_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] resource_kind: Resource kind. Supported values : `"DaemonSet" | "Deployment" | "Node" | "Pod" | "StatefulSet"` (string)
        :param pulumi.Input[str] event_type: Event type. Supported values : `"Warning" | "Normal"`. Default: `Warning` (string)
        """
        pulumi.set(__self__, "resource_kind", resource_kind)
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)

    @property
    @pulumi.getter(name="resourceKind")
    def resource_kind(self) -> pulumi.Input[str]:
        """
        Resource kind. Supported values : `"DaemonSet" | "Deployment" | "Node" | "Pod" | "StatefulSet"` (string)
        """
        return pulumi.get(self, "resource_kind")

    @resource_kind.setter
    def resource_kind(self, value: pulumi.Input[str]):
        pulumi.set(self, "resource_kind", value)

    @property
    @pulumi.getter(name="eventType")
    def event_type(self) -> Optional[pulumi.Input[str]]:
        """
        Event type. Supported values : `"Warning" | "Normal"`. Default: `Warning` (string)
        """
        return pulumi.get(self, "event_type")

    @event_type.setter
    def event_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "event_type", value)


@pulumi.input_type
class ClusterAlertRuleMetricRuleArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[str],
                 expression: pulumi.Input[str],
                 threshold_value: pulumi.Input[float],
                 comparison: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] duration: Metric rule duration (string)
        :param pulumi.Input[str] expression: Metric rule expression (string)
        :param pulumi.Input[float] threshold_value: Metric rule threshold value (float64)
        :param pulumi.Input[str] comparison: Metric rule comparison. Supported values : `"equal" | "greater-or-equal" | "greater-than" | "less-or-equal" | "less-than" | "not-equal" | "has-value"`. Default: `equal`  (string)
        :param pulumi.Input[str] description: Metric rule description (string)
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[str]:
        """
        Metric rule duration (string)
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: pulumi.Input[str]):
        pulumi.set(self, "duration", value)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Metric rule expression (string)
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> pulumi.Input[float]:
        """
        Metric rule threshold value (float64)
        """
        return pulumi.get(self, "threshold_value")

    @threshold_value.setter
    def threshold_value(self, value: pulumi.Input[float]):
        pulumi.set(self, "threshold_value", value)

    @property
    @pulumi.getter
    def comparison(self) -> Optional[pulumi.Input[str]]:
        """
        Metric rule comparison. Supported values : `"equal" | "greater-or-equal" | "greater-than" | "less-or-equal" | "less-than" | "not-equal" | "has-value"`. Default: `equal`  (string)
        """
        return pulumi.get(self, "comparison")

    @comparison.setter
    def comparison(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "comparison", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Metric rule description (string)
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ClusterAlertRuleNodeRuleArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 cpu_threshold: Optional[pulumi.Input[float]] = None,
                 mem_threshold: Optional[pulumi.Input[float]] = None,
                 node_id: Optional[pulumi.Input[str]] = None,
                 selector: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] condition: System service rule condition. Supported values : `"controller-manager" | "etcd" | "scheduler"`. Default: `scheduler` (string)
        :param pulumi.Input[float] cpu_threshold: Node rule cpu threshold. Default: `70` (int)
        :param pulumi.Input[float] mem_threshold: Node rule mem threshold. Default: `70` (int)
        :param pulumi.Input[str] node_id: Node ID (string)
        :param pulumi.Input[Mapping[str, Any]] selector: Node rule selector (map)
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if cpu_threshold is not None:
            pulumi.set(__self__, "cpu_threshold", cpu_threshold)
        if mem_threshold is not None:
            pulumi.set(__self__, "mem_threshold", mem_threshold)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        System service rule condition. Supported values : `"controller-manager" | "etcd" | "scheduler"`. Default: `scheduler` (string)
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)

    @property
    @pulumi.getter(name="cpuThreshold")
    def cpu_threshold(self) -> Optional[pulumi.Input[float]]:
        """
        Node rule cpu threshold. Default: `70` (int)
        """
        return pulumi.get(self, "cpu_threshold")

    @cpu_threshold.setter
    def cpu_threshold(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cpu_threshold", value)

    @property
    @pulumi.getter(name="memThreshold")
    def mem_threshold(self) -> Optional[pulumi.Input[float]]:
        """
        Node rule mem threshold. Default: `70` (int)
        """
        return pulumi.get(self, "mem_threshold")

    @mem_threshold.setter
    def mem_threshold(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "mem_threshold", value)

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[str]]:
        """
        Node ID (string)
        """
        return pulumi.get(self, "node_id")

    @node_id.setter
    def node_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_id", value)

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Node rule selector (map)
        """
        return pulumi.get(self, "selector")

    @selector.setter
    def selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "selector", value)


@pulumi.input_type
class ClusterAlertRuleSystemServiceRuleArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: System service rule condition. Supported values : `"controller-manager" | "etcd" | "scheduler"`. Default: `scheduler` (string)
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        System service rule condition. Supported values : `"controller-manager" | "etcd" | "scheduler"`. Default: `scheduler` (string)
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)


@pulumi.input_type
class ClusterAlterGroupRecipientArgs:
    def __init__(__self__, *,
                 notifier_id: pulumi.Input[str],
                 default_recipient: Optional[pulumi.Input[bool]] = None,
                 notifier_type: Optional[pulumi.Input[str]] = None,
                 recipient: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "notifier_id", notifier_id)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)
        if notifier_type is not None:
            pulumi.set(__self__, "notifier_type", notifier_type)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "notifier_id")

    @notifier_id.setter
    def notifier_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "notifier_id", value)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "default_recipient")

    @default_recipient.setter
    def default_recipient(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "default_recipient", value)

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "notifier_type")

    @notifier_type.setter
    def notifier_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "notifier_type", value)

    @property
    @pulumi.getter
    def recipient(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "recipient")

    @recipient.setter
    def recipient(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recipient", value)


@pulumi.input_type
class ClusterAlterRuleEventRuleArgs:
    def __init__(__self__, *,
                 resource_kind: pulumi.Input[str],
                 event_type: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "resource_kind", resource_kind)
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)

    @property
    @pulumi.getter(name="resourceKind")
    def resource_kind(self) -> pulumi.Input[str]:
        return pulumi.get(self, "resource_kind")

    @resource_kind.setter
    def resource_kind(self, value: pulumi.Input[str]):
        pulumi.set(self, "resource_kind", value)

    @property
    @pulumi.getter(name="eventType")
    def event_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "event_type")

    @event_type.setter
    def event_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "event_type", value)


@pulumi.input_type
class ClusterAlterRuleMetricRuleArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[str],
                 expression: pulumi.Input[str],
                 threshold_value: pulumi.Input[float],
                 comparison: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[str]:
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: pulumi.Input[str]):
        pulumi.set(self, "duration", value)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> pulumi.Input[float]:
        return pulumi.get(self, "threshold_value")

    @threshold_value.setter
    def threshold_value(self, value: pulumi.Input[float]):
        pulumi.set(self, "threshold_value", value)

    @property
    @pulumi.getter
    def comparison(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "comparison")

    @comparison.setter
    def comparison(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "comparison", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ClusterAlterRuleNodeRuleArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 cpu_threshold: Optional[pulumi.Input[float]] = None,
                 mem_threshold: Optional[pulumi.Input[float]] = None,
                 node_id: Optional[pulumi.Input[str]] = None,
                 selector: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if cpu_threshold is not None:
            pulumi.set(__self__, "cpu_threshold", cpu_threshold)
        if mem_threshold is not None:
            pulumi.set(__self__, "mem_threshold", mem_threshold)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)

    @property
    @pulumi.getter(name="cpuThreshold")
    def cpu_threshold(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cpu_threshold")

    @cpu_threshold.setter
    def cpu_threshold(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cpu_threshold", value)

    @property
    @pulumi.getter(name="memThreshold")
    def mem_threshold(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "mem_threshold")

    @mem_threshold.setter
    def mem_threshold(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "mem_threshold", value)

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "node_id")

    @node_id.setter
    def node_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_id", value)

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "selector")

    @selector.setter
    def selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "selector", value)


@pulumi.input_type
class ClusterAlterRuleSystemServiceRuleArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None):
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)


@pulumi.input_type
class ClusterClusterAuthEndpointArgs:
    def __init__(__self__, *,
                 ca_certs: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 fqdn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] ca_certs: CA certs for the authorized cluster endpoint (string)
        :param pulumi.Input[bool] enabled: Enable scheduled cluster scan. Default: `false` (bool)
        :param pulumi.Input[str] fqdn: FQDN for the authorized cluster endpoint (string)
        """
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[pulumi.Input[str]]:
        """
        CA certs for the authorized cluster endpoint (string)
        """
        return pulumi.get(self, "ca_certs")

    @ca_certs.setter
    def ca_certs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_certs", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable scheduled cluster scan. Default: `false` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[pulumi.Input[str]]:
        """
        FQDN for the authorized cluster endpoint (string)
        """
        return pulumi.get(self, "fqdn")

    @fqdn.setter
    def fqdn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fqdn", value)


@pulumi.input_type
class ClusterClusterMonitoringInputArgs:
    def __init__(__self__, *,
                 answers: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] answers: Key/value answers for monitor input (map)
        :param pulumi.Input[str] version: rancher-monitoring chart version (string)
        """
        if answers is not None:
            pulumi.set(__self__, "answers", answers)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def answers(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Key/value answers for monitor input (map)
        """
        return pulumi.get(self, "answers")

    @answers.setter
    def answers(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "answers", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        rancher-monitoring chart version (string)
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class ClusterClusterRegistrationTokenArgs:
    def __init__(__self__, *,
                 annotations: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 cluster_id: Optional[pulumi.Input[str]] = None,
                 command: Optional[pulumi.Input[str]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 insecure_command: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 manifest_url: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 node_command: Optional[pulumi.Input[str]] = None,
                 token: Optional[pulumi.Input[str]] = None,
                 windows_node_command: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] annotations: Annotations for cluster registration token object (map)
        :param pulumi.Input[str] cluster_id: Cluster ID (string)
        :param pulumi.Input[str] command: Command to execute in a imported k8s cluster (string)
        :param pulumi.Input[str] id: (Computed) The ID of the resource (string)
        :param pulumi.Input[str] insecure_command: Insecure command to execute in a imported k8s cluster (string)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for cluster registration token object (map)
        :param pulumi.Input[str] manifest_url: K8s manifest url to execute with `kubectl` to import an existing k8s cluster (string)
        :param pulumi.Input[str] name: Name of cluster registration token (string)
        :param pulumi.Input[str] node_command: Node command to execute in linux nodes for custom k8s cluster (string)
        :param pulumi.Input[str] token: Token for cluster registration token object (string)
        :param pulumi.Input[str] windows_node_command: Node command to execute in windows nodes for custom k8s cluster (string)
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if command is not None:
            pulumi.set(__self__, "command", command)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if insecure_command is not None:
            pulumi.set(__self__, "insecure_command", insecure_command)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if manifest_url is not None:
            pulumi.set(__self__, "manifest_url", manifest_url)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_command is not None:
            pulumi.set(__self__, "node_command", node_command)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if windows_node_command is not None:
            pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Annotations for cluster registration token object (map)
        """
        return pulumi.get(self, "annotations")

    @annotations.setter
    def annotations(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "annotations", value)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster ID (string)
        """
        return pulumi.get(self, "cluster_id")

    @cluster_id.setter
    def cluster_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_id", value)

    @property
    @pulumi.getter
    def command(self) -> Optional[pulumi.Input[str]]:
        """
        Command to execute in a imported k8s cluster (string)
        """
        return pulumi.get(self, "command")

    @command.setter
    def command(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "command", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> Optional[pulumi.Input[str]]:
        """
        Insecure command to execute in a imported k8s cluster (string)
        """
        return pulumi.get(self, "insecure_command")

    @insecure_command.setter
    def insecure_command(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "insecure_command", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for cluster registration token object (map)
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> Optional[pulumi.Input[str]]:
        """
        K8s manifest url to execute with `kubectl` to import an existing k8s cluster (string)
        """
        return pulumi.get(self, "manifest_url")

    @manifest_url.setter
    def manifest_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "manifest_url", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of cluster registration token (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> Optional[pulumi.Input[str]]:
        """
        Node command to execute in linux nodes for custom k8s cluster (string)
        """
        return pulumi.get(self, "node_command")

    @node_command.setter
    def node_command(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_command", value)

    @property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[str]]:
        """
        Token for cluster registration token object (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token", value)

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> Optional[pulumi.Input[str]]:
        """
        Node command to execute in windows nodes for custom k8s cluster (string)
        """
        return pulumi.get(self, "windows_node_command")

    @windows_node_command.setter
    def windows_node_command(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "windows_node_command", value)


@pulumi.input_type
class ClusterClusterTemplateAnswersArgs:
    def __init__(__self__, *,
                 cluster_id: Optional[pulumi.Input[str]] = None,
                 project_id: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] cluster_id: Cluster ID (string)
        :param pulumi.Input[str] project_id: Project ID to apply answer (string)
        :param pulumi.Input[Mapping[str, Any]] values: Key/values for answer (map)
        """
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster ID (string)
        """
        return pulumi.get(self, "cluster_id")

    @cluster_id.setter
    def cluster_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[pulumi.Input[str]]:
        """
        Project ID to apply answer (string)
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Key/values for answer (map)
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class ClusterClusterTemplateQuestionArgs:
    def __init__(__self__, *,
                 default: pulumi.Input[str],
                 variable: pulumi.Input[str],
                 required: Optional[pulumi.Input[bool]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] default: Default variable value (string)
        :param pulumi.Input[str] variable: Variable name (string)
        :param pulumi.Input[bool] required: Required variable. Default `false` (bool)
        :param pulumi.Input[str] type: Variable type. `boolean`, `int` and `string` are allowed. Default `string` (string)
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "variable", variable)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def default(self) -> pulumi.Input[str]:
        """
        Default variable value (string)
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: pulumi.Input[str]):
        pulumi.set(self, "default", value)

    @property
    @pulumi.getter
    def variable(self) -> pulumi.Input[str]:
        """
        Variable name (string)
        """
        return pulumi.get(self, "variable")

    @variable.setter
    def variable(self, value: pulumi.Input[str]):
        pulumi.set(self, "variable", value)

    @property
    @pulumi.getter
    def required(self) -> Optional[pulumi.Input[bool]]:
        """
        Required variable. Default `false` (bool)
        """
        return pulumi.get(self, "required")

    @required.setter
    def required(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "required", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Variable type. `boolean`, `int` and `string` are allowed. Default `string` (string)
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ClusterEksConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 kubernetes_version: pulumi.Input[str],
                 secret_key: pulumi.Input[str],
                 ami: Optional[pulumi.Input[str]] = None,
                 associate_worker_node_public_ip: Optional[pulumi.Input[bool]] = None,
                 desired_nodes: Optional[pulumi.Input[float]] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 key_pair_name: Optional[pulumi.Input[str]] = None,
                 maximum_nodes: Optional[pulumi.Input[float]] = None,
                 minimum_nodes: Optional[pulumi.Input[float]] = None,
                 node_volume_size: Optional[pulumi.Input[float]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 security_groups: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 service_role: Optional[pulumi.Input[str]] = None,
                 session_token: Optional[pulumi.Input[str]] = None,
                 subnets: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 user_data: Optional[pulumi.Input[str]] = None,
                 virtual_network: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_key: The AWS Client ID to use (string)
        :param pulumi.Input[str] kubernetes_version: The Kubernetes master version (string)
        :param pulumi.Input[str] secret_key: The AWS Client Secret associated with the Client ID (string)
        :param pulumi.Input[str] ami: AMI ID to use for the worker nodes instead of the default (string)
        :param pulumi.Input[bool] associate_worker_node_public_ip: Associate public ip EKS worker nodes. Default `true` (bool)
        :param pulumi.Input[float] desired_nodes: The desired number of worker nodes. Just for Rancher v2.3.x and above. Default `3` (int)
        :param pulumi.Input[str] instance_type: The type of machine to use for worker nodes. Default `t2.medium` (string)
        :param pulumi.Input[str] key_pair_name: Allow user to specify key name to use. Just for Rancher v2.2.7 and above (string)
        :param pulumi.Input[float] maximum_nodes: The maximum number of worker nodes. Default `3` (int)
        :param pulumi.Input[float] minimum_nodes: The minimum number of worker nodes. Default `1` (int)
        :param pulumi.Input[float] node_volume_size: The volume size for each node. Default `20` (int)
        :param pulumi.Input[str] region: GKE cluster region. Conflicts with `zone` (string)
        :param pulumi.Input[List[pulumi.Input[str]]] security_groups: List of security groups to use for the cluster. If it's not specified Rancher will create a new security group (list)
        :param pulumi.Input[str] service_role: The service role to use to perform the cluster operations in AWS. If it's not specified Rancher will create a new service role (string)
        :param pulumi.Input[str] session_token: A session token to use with the client key and secret if applicable (string)
        :param pulumi.Input[List[pulumi.Input[str]]] subnets: List of subnets in the virtual network to use. If it's not specified Rancher will create 3 news subnets (list)
        :param pulumi.Input[str] user_data: Pass user-data to the nodes to perform automated configuration tasks (string)
        :param pulumi.Input[str] virtual_network: The name of the virtual network to use. If it's not specified Rancher will create a new VPC (string)
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "secret_key", secret_key)
        if ami is not None:
            pulumi.set(__self__, "ami", ami)
        if associate_worker_node_public_ip is not None:
            pulumi.set(__self__, "associate_worker_node_public_ip", associate_worker_node_public_ip)
        if desired_nodes is not None:
            pulumi.set(__self__, "desired_nodes", desired_nodes)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if key_pair_name is not None:
            pulumi.set(__self__, "key_pair_name", key_pair_name)
        if maximum_nodes is not None:
            pulumi.set(__self__, "maximum_nodes", maximum_nodes)
        if minimum_nodes is not None:
            pulumi.set(__self__, "minimum_nodes", minimum_nodes)
        if node_volume_size is not None:
            pulumi.set(__self__, "node_volume_size", node_volume_size)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if service_role is not None:
            pulumi.set(__self__, "service_role", service_role)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if virtual_network is not None:
            pulumi.set(__self__, "virtual_network", virtual_network)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        The AWS Client ID to use (string)
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> pulumi.Input[str]:
        """
        The Kubernetes master version (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @kubernetes_version.setter
    def kubernetes_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "kubernetes_version", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[str]:
        """
        The AWS Client Secret associated with the Client ID (string)
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_key", value)

    @property
    @pulumi.getter
    def ami(self) -> Optional[pulumi.Input[str]]:
        """
        AMI ID to use for the worker nodes instead of the default (string)
        """
        return pulumi.get(self, "ami")

    @ami.setter
    def ami(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ami", value)

    @property
    @pulumi.getter(name="associateWorkerNodePublicIp")
    def associate_worker_node_public_ip(self) -> Optional[pulumi.Input[bool]]:
        """
        Associate public ip EKS worker nodes. Default `true` (bool)
        """
        return pulumi.get(self, "associate_worker_node_public_ip")

    @associate_worker_node_public_ip.setter
    def associate_worker_node_public_ip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "associate_worker_node_public_ip", value)

    @property
    @pulumi.getter(name="desiredNodes")
    def desired_nodes(self) -> Optional[pulumi.Input[float]]:
        """
        The desired number of worker nodes. Just for Rancher v2.3.x and above. Default `3` (int)
        """
        return pulumi.get(self, "desired_nodes")

    @desired_nodes.setter
    def desired_nodes(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "desired_nodes", value)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of machine to use for worker nodes. Default `t2.medium` (string)
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="keyPairName")
    def key_pair_name(self) -> Optional[pulumi.Input[str]]:
        """
        Allow user to specify key name to use. Just for Rancher v2.2.7 and above (string)
        """
        return pulumi.get(self, "key_pair_name")

    @key_pair_name.setter
    def key_pair_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_pair_name", value)

    @property
    @pulumi.getter(name="maximumNodes")
    def maximum_nodes(self) -> Optional[pulumi.Input[float]]:
        """
        The maximum number of worker nodes. Default `3` (int)
        """
        return pulumi.get(self, "maximum_nodes")

    @maximum_nodes.setter
    def maximum_nodes(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "maximum_nodes", value)

    @property
    @pulumi.getter(name="minimumNodes")
    def minimum_nodes(self) -> Optional[pulumi.Input[float]]:
        """
        The minimum number of worker nodes. Default `1` (int)
        """
        return pulumi.get(self, "minimum_nodes")

    @minimum_nodes.setter
    def minimum_nodes(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "minimum_nodes", value)

    @property
    @pulumi.getter(name="nodeVolumeSize")
    def node_volume_size(self) -> Optional[pulumi.Input[float]]:
        """
        The volume size for each node. Default `20` (int)
        """
        return pulumi.get(self, "node_volume_size")

    @node_volume_size.setter
    def node_volume_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "node_volume_size", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster region. Conflicts with `zone` (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        List of security groups to use for the cluster. If it's not specified Rancher will create a new security group (list)
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "security_groups", value)

    @property
    @pulumi.getter(name="serviceRole")
    def service_role(self) -> Optional[pulumi.Input[str]]:
        """
        The service role to use to perform the cluster operations in AWS. If it's not specified Rancher will create a new service role (string)
        """
        return pulumi.get(self, "service_role")

    @service_role.setter
    def service_role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_role", value)

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[pulumi.Input[str]]:
        """
        A session token to use with the client key and secret if applicable (string)
        """
        return pulumi.get(self, "session_token")

    @session_token.setter
    def session_token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "session_token", value)

    @property
    @pulumi.getter
    def subnets(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        List of subnets in the virtual network to use. If it's not specified Rancher will create 3 news subnets (list)
        """
        return pulumi.get(self, "subnets")

    @subnets.setter
    def subnets(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "subnets", value)

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[pulumi.Input[str]]:
        """
        Pass user-data to the nodes to perform automated configuration tasks (string)
        """
        return pulumi.get(self, "user_data")

    @user_data.setter
    def user_data(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_data", value)

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the virtual network to use. If it's not specified Rancher will create a new VPC (string)
        """
        return pulumi.get(self, "virtual_network")

    @virtual_network.setter
    def virtual_network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "virtual_network", value)


@pulumi.input_type
class ClusterGkeConfigArgs:
    def __init__(__self__, *,
                 cluster_ipv4_cidr: pulumi.Input[str],
                 credential: pulumi.Input[str],
                 disk_type: pulumi.Input[str],
                 image_type: pulumi.Input[str],
                 ip_policy_cluster_ipv4_cidr_block: pulumi.Input[str],
                 ip_policy_cluster_secondary_range_name: pulumi.Input[str],
                 ip_policy_node_ipv4_cidr_block: pulumi.Input[str],
                 ip_policy_services_ipv4_cidr_block: pulumi.Input[str],
                 ip_policy_services_secondary_range_name: pulumi.Input[str],
                 ip_policy_subnetwork_name: pulumi.Input[str],
                 locations: pulumi.Input[List[pulumi.Input[str]]],
                 machine_type: pulumi.Input[str],
                 maintenance_window: pulumi.Input[str],
                 master_ipv4_cidr_block: pulumi.Input[str],
                 master_version: pulumi.Input[str],
                 network: pulumi.Input[str],
                 node_pool: pulumi.Input[str],
                 node_version: pulumi.Input[str],
                 oauth_scopes: pulumi.Input[List[pulumi.Input[str]]],
                 project_id: pulumi.Input[str],
                 service_account: pulumi.Input[str],
                 sub_network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 disk_size_gb: Optional[pulumi.Input[float]] = None,
                 enable_alpha_feature: Optional[pulumi.Input[bool]] = None,
                 enable_auto_repair: Optional[pulumi.Input[bool]] = None,
                 enable_auto_upgrade: Optional[pulumi.Input[bool]] = None,
                 enable_horizontal_pod_autoscaling: Optional[pulumi.Input[bool]] = None,
                 enable_http_load_balancing: Optional[pulumi.Input[bool]] = None,
                 enable_kubernetes_dashboard: Optional[pulumi.Input[bool]] = None,
                 enable_legacy_abac: Optional[pulumi.Input[bool]] = None,
                 enable_master_authorized_network: Optional[pulumi.Input[bool]] = None,
                 enable_network_policy_config: Optional[pulumi.Input[bool]] = None,
                 enable_nodepool_autoscaling: Optional[pulumi.Input[bool]] = None,
                 enable_private_endpoint: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None,
                 enable_stackdriver_logging: Optional[pulumi.Input[bool]] = None,
                 enable_stackdriver_monitoring: Optional[pulumi.Input[bool]] = None,
                 ip_policy_create_subnetwork: Optional[pulumi.Input[bool]] = None,
                 issue_client_certificate: Optional[pulumi.Input[bool]] = None,
                 kubernetes_dashboard: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 local_ssd_count: Optional[pulumi.Input[float]] = None,
                 master_authorized_network_cidr_blocks: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 max_node_count: Optional[pulumi.Input[float]] = None,
                 min_node_count: Optional[pulumi.Input[float]] = None,
                 node_count: Optional[pulumi.Input[float]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 resource_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 taints: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 use_ip_aliases: Optional[pulumi.Input[bool]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cluster_ipv4_cidr: The IP address range of the container pods (string)
        :param pulumi.Input[str] credential: The contents of the GC credential file (string)
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (string)
        :param pulumi.Input[str] image_type: The image to use for the worker nodes (string)
        :param pulumi.Input[str] ip_policy_cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs (string)
        :param pulumi.Input[str] ip_policy_cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block (string)
        :param pulumi.Input[str] ip_policy_node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster (string)
        :param pulumi.Input[str] ip_policy_services_ipv4_cidr_block: The IP address range of the services IPs in this cluster (string)
        :param pulumi.Input[str] ip_policy_services_secondary_range_name: The name of the secondary range to be used for the services CIDR block (string)
        :param pulumi.Input[str] ip_policy_subnetwork_name: A custom subnetwork name to be used if createSubnetwork is true (string)
        :param pulumi.Input[List[pulumi.Input[str]]] locations: Locations for GKE cluster (list)
        :param pulumi.Input[str] machine_type: Machine type for GKE cluster (string)
        :param pulumi.Input[str] maintenance_window: Maintenance window for GKE cluster (string)
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network (string)
        :param pulumi.Input[str] master_version: Master version for GKE cluster (string)
        :param pulumi.Input[str] network: Network for GKE cluster (string)
        :param pulumi.Input[str] node_pool: The ID of the cluster node pool (string)
        :param pulumi.Input[str] node_version: Node version for GKE cluster (string)
        :param pulumi.Input[List[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the default service account (list)
        :param pulumi.Input[str] project_id: Project ID to apply answer (string)
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs (string)
        :param pulumi.Input[str] sub_network: Subnetwork for GKE cluster (string)
        :param pulumi.Input[str] description: An optional description of this cluster (string)
        :param pulumi.Input[float] disk_size_gb: Size of the disk attached to each node. Default `100` (int)
        :param pulumi.Input[bool] enable_alpha_feature: To enable Kubernetes alpha feature. Default `true` (bool)
        :param pulumi.Input[bool] enable_auto_repair: Specifies whether the node auto-repair is enabled for the node pool. Default `false` (bool)
        :param pulumi.Input[bool] enable_auto_upgrade: Specifies whether node auto-upgrade is enabled for the node pool. Default `false` (bool)
        :param pulumi.Input[bool] enable_horizontal_pod_autoscaling: Enable horizontal pod autoscaling for the cluster. Default `true` (bool)
        :param pulumi.Input[bool] enable_http_load_balancing: Enable HTTP load balancing on GKE cluster. Default `true` (bool)
        :param pulumi.Input[bool] enable_kubernetes_dashboard: Whether to enable the Kubernetes dashboard. Default `false` (bool)
        :param pulumi.Input[bool] enable_legacy_abac: Whether to enable legacy abac on the cluster. Default `false` (bool)
        :param pulumi.Input[bool] enable_network_policy_config: Enable network policy config for the cluster. Default `true` (bool)
        :param pulumi.Input[bool] enable_nodepool_autoscaling: Enable nodepool autoscaling. Default `false` (bool)
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint. Default `false` (bool)
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP address only. Default `false` (bool)
        :param pulumi.Input[bool] enable_stackdriver_logging: Enable stackdriver monitoring. Default `true` (bool)
        :param pulumi.Input[bool] enable_stackdriver_monitoring: Enable stackdriver monitoring on GKE cluster (bool)
        :param pulumi.Input[bool] ip_policy_create_subnetwork: Whether a new subnetwork will be created automatically for the cluster. Default `false` (bool)
        :param pulumi.Input[bool] issue_client_certificate: Issue a client certificate. Default `false` (bool)
        :param pulumi.Input[bool] kubernetes_dashboard: Enable the Kubernetes dashboard. Default `false` (bool)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for cluster registration token object (map)
        :param pulumi.Input[float] local_ssd_count: The number of local SSD disks to be attached to the node. Default `0` (int)
        :param pulumi.Input[List[pulumi.Input[str]]] master_authorized_network_cidr_blocks: Define up to 10 external networks that could access Kubernetes master through HTTPS (list)
        :param pulumi.Input[float] max_node_count: Maximum number of nodes in the NodePool. Must be >= minNodeCount. There has to enough quota to scale up the cluster. Default `0` (int)
        :param pulumi.Input[float] min_node_count: Minimmum number of nodes in the NodePool. Must be >= 1 and <= maxNodeCount. Default `0` (int)
        :param pulumi.Input[float] node_count: Node count for GKE cluster. Default `3` (int)
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. Default `false` (bool)
        :param pulumi.Input[str] region: GKE cluster region. Conflicts with `zone` (string)
        :param pulumi.Input[Mapping[str, Any]] resource_labels: The map of Kubernetes labels to be applied to each cluster (map)
        :param pulumi.Input[List[pulumi.Input[str]]] taints: List of Kubernetes taints to be applied to each node (list)
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster. Default `false` (bool)
        :param pulumi.Input[str] zone: GKE cluster zone. Conflicts with `region` (string)
        """
        pulumi.set(__self__, "cluster_ipv4_cidr", cluster_ipv4_cidr)
        pulumi.set(__self__, "credential", credential)
        pulumi.set(__self__, "disk_type", disk_type)
        pulumi.set(__self__, "image_type", image_type)
        pulumi.set(__self__, "ip_policy_cluster_ipv4_cidr_block", ip_policy_cluster_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_cluster_secondary_range_name", ip_policy_cluster_secondary_range_name)
        pulumi.set(__self__, "ip_policy_node_ipv4_cidr_block", ip_policy_node_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_services_ipv4_cidr_block", ip_policy_services_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_services_secondary_range_name", ip_policy_services_secondary_range_name)
        pulumi.set(__self__, "ip_policy_subnetwork_name", ip_policy_subnetwork_name)
        pulumi.set(__self__, "locations", locations)
        pulumi.set(__self__, "machine_type", machine_type)
        pulumi.set(__self__, "maintenance_window", maintenance_window)
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        pulumi.set(__self__, "master_version", master_version)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "node_pool", node_pool)
        pulumi.set(__self__, "node_version", node_version)
        pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "service_account", service_account)
        pulumi.set(__self__, "sub_network", sub_network)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if enable_alpha_feature is not None:
            pulumi.set(__self__, "enable_alpha_feature", enable_alpha_feature)
        if enable_auto_repair is not None:
            pulumi.set(__self__, "enable_auto_repair", enable_auto_repair)
        if enable_auto_upgrade is not None:
            pulumi.set(__self__, "enable_auto_upgrade", enable_auto_upgrade)
        if enable_horizontal_pod_autoscaling is not None:
            pulumi.set(__self__, "enable_horizontal_pod_autoscaling", enable_horizontal_pod_autoscaling)
        if enable_http_load_balancing is not None:
            pulumi.set(__self__, "enable_http_load_balancing", enable_http_load_balancing)
        if enable_kubernetes_dashboard is not None:
            pulumi.set(__self__, "enable_kubernetes_dashboard", enable_kubernetes_dashboard)
        if enable_legacy_abac is not None:
            pulumi.set(__self__, "enable_legacy_abac", enable_legacy_abac)
        if enable_master_authorized_network is not None:
            pulumi.set(__self__, "enable_master_authorized_network", enable_master_authorized_network)
        if enable_network_policy_config is not None:
            pulumi.set(__self__, "enable_network_policy_config", enable_network_policy_config)
        if enable_nodepool_autoscaling is not None:
            pulumi.set(__self__, "enable_nodepool_autoscaling", enable_nodepool_autoscaling)
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if enable_stackdriver_logging is not None:
            pulumi.set(__self__, "enable_stackdriver_logging", enable_stackdriver_logging)
        if enable_stackdriver_monitoring is not None:
            pulumi.set(__self__, "enable_stackdriver_monitoring", enable_stackdriver_monitoring)
        if ip_policy_create_subnetwork is not None:
            pulumi.set(__self__, "ip_policy_create_subnetwork", ip_policy_create_subnetwork)
        if issue_client_certificate is not None:
            pulumi.set(__self__, "issue_client_certificate", issue_client_certificate)
        if kubernetes_dashboard is not None:
            pulumi.set(__self__, "kubernetes_dashboard", kubernetes_dashboard)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)
        if master_authorized_network_cidr_blocks is not None:
            pulumi.set(__self__, "master_authorized_network_cidr_blocks", master_authorized_network_cidr_blocks)
        if max_node_count is not None:
            pulumi.set(__self__, "max_node_count", max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, "min_node_count", min_node_count)
        if node_count is not None:
            pulumi.set(__self__, "node_count", node_count)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if resource_labels is not None:
            pulumi.set(__self__, "resource_labels", resource_labels)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if use_ip_aliases is not None:
            pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="clusterIpv4Cidr")
    def cluster_ipv4_cidr(self) -> pulumi.Input[str]:
        """
        The IP address range of the container pods (string)
        """
        return pulumi.get(self, "cluster_ipv4_cidr")

    @cluster_ipv4_cidr.setter
    def cluster_ipv4_cidr(self, value: pulumi.Input[str]):
        pulumi.set(self, "cluster_ipv4_cidr", value)

    @property
    @pulumi.getter
    def credential(self) -> pulumi.Input[str]:
        """
        The contents of the GC credential file (string)
        """
        return pulumi.get(self, "credential")

    @credential.setter
    def credential(self, value: pulumi.Input[str]):
        pulumi.set(self, "credential", value)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> pulumi.Input[str]:
        """
        Type of the disk attached to each node (string)
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> pulumi.Input[str]:
        """
        The image to use for the worker nodes (string)
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter(name="ipPolicyClusterIpv4CidrBlock")
    def ip_policy_cluster_ipv4_cidr_block(self) -> pulumi.Input[str]:
        """
        The IP address range for the cluster pod IPs (string)
        """
        return pulumi.get(self, "ip_policy_cluster_ipv4_cidr_block")

    @ip_policy_cluster_ipv4_cidr_block.setter
    def ip_policy_cluster_ipv4_cidr_block(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_policy_cluster_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="ipPolicyClusterSecondaryRangeName")
    def ip_policy_cluster_secondary_range_name(self) -> pulumi.Input[str]:
        """
        The name of the secondary range to be used for the cluster CIDR block (string)
        """
        return pulumi.get(self, "ip_policy_cluster_secondary_range_name")

    @ip_policy_cluster_secondary_range_name.setter
    def ip_policy_cluster_secondary_range_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_policy_cluster_secondary_range_name", value)

    @property
    @pulumi.getter(name="ipPolicyNodeIpv4CidrBlock")
    def ip_policy_node_ipv4_cidr_block(self) -> pulumi.Input[str]:
        """
        The IP address range of the instance IPs in this cluster (string)
        """
        return pulumi.get(self, "ip_policy_node_ipv4_cidr_block")

    @ip_policy_node_ipv4_cidr_block.setter
    def ip_policy_node_ipv4_cidr_block(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_policy_node_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="ipPolicyServicesIpv4CidrBlock")
    def ip_policy_services_ipv4_cidr_block(self) -> pulumi.Input[str]:
        """
        The IP address range of the services IPs in this cluster (string)
        """
        return pulumi.get(self, "ip_policy_services_ipv4_cidr_block")

    @ip_policy_services_ipv4_cidr_block.setter
    def ip_policy_services_ipv4_cidr_block(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_policy_services_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="ipPolicyServicesSecondaryRangeName")
    def ip_policy_services_secondary_range_name(self) -> pulumi.Input[str]:
        """
        The name of the secondary range to be used for the services CIDR block (string)
        """
        return pulumi.get(self, "ip_policy_services_secondary_range_name")

    @ip_policy_services_secondary_range_name.setter
    def ip_policy_services_secondary_range_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_policy_services_secondary_range_name", value)

    @property
    @pulumi.getter(name="ipPolicySubnetworkName")
    def ip_policy_subnetwork_name(self) -> pulumi.Input[str]:
        """
        A custom subnetwork name to be used if createSubnetwork is true (string)
        """
        return pulumi.get(self, "ip_policy_subnetwork_name")

    @ip_policy_subnetwork_name.setter
    def ip_policy_subnetwork_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "ip_policy_subnetwork_name", value)

    @property
    @pulumi.getter
    def locations(self) -> pulumi.Input[List[pulumi.Input[str]]]:
        """
        Locations for GKE cluster (list)
        """
        return pulumi.get(self, "locations")

    @locations.setter
    def locations(self, value: pulumi.Input[List[pulumi.Input[str]]]):
        pulumi.set(self, "locations", value)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> pulumi.Input[str]:
        """
        Machine type for GKE cluster (string)
        """
        return pulumi.get(self, "machine_type")

    @machine_type.setter
    def machine_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "machine_type", value)

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> pulumi.Input[str]:
        """
        Maintenance window for GKE cluster (string)
        """
        return pulumi.get(self, "maintenance_window")

    @maintenance_window.setter
    def maintenance_window(self, value: pulumi.Input[str]):
        pulumi.set(self, "maintenance_window", value)

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> pulumi.Input[str]:
        """
        The IP range in CIDR notation to use for the hosted master network (string)
        """
        return pulumi.get(self, "master_ipv4_cidr_block")

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: pulumi.Input[str]):
        pulumi.set(self, "master_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="masterVersion")
    def master_version(self) -> pulumi.Input[str]:
        """
        Master version for GKE cluster (string)
        """
        return pulumi.get(self, "master_version")

    @master_version.setter
    def master_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "master_version", value)

    @property
    @pulumi.getter
    def network(self) -> pulumi.Input[str]:
        """
        Network for GKE cluster (string)
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter(name="nodePool")
    def node_pool(self) -> pulumi.Input[str]:
        """
        The ID of the cluster node pool (string)
        """
        return pulumi.get(self, "node_pool")

    @node_pool.setter
    def node_pool(self, value: pulumi.Input[str]):
        pulumi.set(self, "node_pool", value)

    @property
    @pulumi.getter(name="nodeVersion")
    def node_version(self) -> pulumi.Input[str]:
        """
        Node version for GKE cluster (string)
        """
        return pulumi.get(self, "node_version")

    @node_version.setter
    def node_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "node_version", value)

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> pulumi.Input[List[pulumi.Input[str]]]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the default service account (list)
        """
        return pulumi.get(self, "oauth_scopes")

    @oauth_scopes.setter
    def oauth_scopes(self, value: pulumi.Input[List[pulumi.Input[str]]]):
        pulumi.set(self, "oauth_scopes", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        Project ID to apply answer (string)
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> pulumi.Input[str]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs (string)
        """
        return pulumi.get(self, "service_account")

    @service_account.setter
    def service_account(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_account", value)

    @property
    @pulumi.getter(name="subNetwork")
    def sub_network(self) -> pulumi.Input[str]:
        """
        Subnetwork for GKE cluster (string)
        """
        return pulumi.get(self, "sub_network")

    @sub_network.setter
    def sub_network(self, value: pulumi.Input[str]):
        pulumi.set(self, "sub_network", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        An optional description of this cluster (string)
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[float]]:
        """
        Size of the disk attached to each node. Default `100` (int)
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter(name="enableAlphaFeature")
    def enable_alpha_feature(self) -> Optional[pulumi.Input[bool]]:
        """
        To enable Kubernetes alpha feature. Default `true` (bool)
        """
        return pulumi.get(self, "enable_alpha_feature")

    @enable_alpha_feature.setter
    def enable_alpha_feature(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_alpha_feature", value)

    @property
    @pulumi.getter(name="enableAutoRepair")
    def enable_auto_repair(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether the node auto-repair is enabled for the node pool. Default `false` (bool)
        """
        return pulumi.get(self, "enable_auto_repair")

    @enable_auto_repair.setter
    def enable_auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_auto_repair", value)

    @property
    @pulumi.getter(name="enableAutoUpgrade")
    def enable_auto_upgrade(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether node auto-upgrade is enabled for the node pool. Default `false` (bool)
        """
        return pulumi.get(self, "enable_auto_upgrade")

    @enable_auto_upgrade.setter
    def enable_auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_auto_upgrade", value)

    @property
    @pulumi.getter(name="enableHorizontalPodAutoscaling")
    def enable_horizontal_pod_autoscaling(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable horizontal pod autoscaling for the cluster. Default `true` (bool)
        """
        return pulumi.get(self, "enable_horizontal_pod_autoscaling")

    @enable_horizontal_pod_autoscaling.setter
    def enable_horizontal_pod_autoscaling(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_horizontal_pod_autoscaling", value)

    @property
    @pulumi.getter(name="enableHttpLoadBalancing")
    def enable_http_load_balancing(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable HTTP load balancing on GKE cluster. Default `true` (bool)
        """
        return pulumi.get(self, "enable_http_load_balancing")

    @enable_http_load_balancing.setter
    def enable_http_load_balancing(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_http_load_balancing", value)

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable the Kubernetes dashboard. Default `false` (bool)
        """
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @enable_kubernetes_dashboard.setter
    def enable_kubernetes_dashboard(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_kubernetes_dashboard", value)

    @property
    @pulumi.getter(name="enableLegacyAbac")
    def enable_legacy_abac(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable legacy abac on the cluster. Default `false` (bool)
        """
        return pulumi.get(self, "enable_legacy_abac")

    @enable_legacy_abac.setter
    def enable_legacy_abac(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_legacy_abac", value)

    @property
    @pulumi.getter(name="enableMasterAuthorizedNetwork")
    def enable_master_authorized_network(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_master_authorized_network")

    @enable_master_authorized_network.setter
    def enable_master_authorized_network(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_master_authorized_network", value)

    @property
    @pulumi.getter(name="enableNetworkPolicyConfig")
    def enable_network_policy_config(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable network policy config for the cluster. Default `true` (bool)
        """
        return pulumi.get(self, "enable_network_policy_config")

    @enable_network_policy_config.setter
    def enable_network_policy_config(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_network_policy_config", value)

    @property
    @pulumi.getter(name="enableNodepoolAutoscaling")
    def enable_nodepool_autoscaling(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable nodepool autoscaling. Default `false` (bool)
        """
        return pulumi.get(self, "enable_nodepool_autoscaling")

    @enable_nodepool_autoscaling.setter
    def enable_nodepool_autoscaling(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nodepool_autoscaling", value)

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint. Default `false` (bool)
        """
        return pulumi.get(self, "enable_private_endpoint")

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_endpoint", value)

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP address only. Default `false` (bool)
        """
        return pulumi.get(self, "enable_private_nodes")

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_nodes", value)

    @property
    @pulumi.getter(name="enableStackdriverLogging")
    def enable_stackdriver_logging(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable stackdriver monitoring. Default `true` (bool)
        """
        return pulumi.get(self, "enable_stackdriver_logging")

    @enable_stackdriver_logging.setter
    def enable_stackdriver_logging(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_stackdriver_logging", value)

    @property
    @pulumi.getter(name="enableStackdriverMonitoring")
    def enable_stackdriver_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable stackdriver monitoring on GKE cluster (bool)
        """
        return pulumi.get(self, "enable_stackdriver_monitoring")

    @enable_stackdriver_monitoring.setter
    def enable_stackdriver_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_stackdriver_monitoring", value)

    @property
    @pulumi.getter(name="ipPolicyCreateSubnetwork")
    def ip_policy_create_subnetwork(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether a new subnetwork will be created automatically for the cluster. Default `false` (bool)
        """
        return pulumi.get(self, "ip_policy_create_subnetwork")

    @ip_policy_create_subnetwork.setter
    def ip_policy_create_subnetwork(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ip_policy_create_subnetwork", value)

    @property
    @pulumi.getter(name="issueClientCertificate")
    def issue_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Issue a client certificate. Default `false` (bool)
        """
        return pulumi.get(self, "issue_client_certificate")

    @issue_client_certificate.setter
    def issue_client_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "issue_client_certificate", value)

    @property
    @pulumi.getter(name="kubernetesDashboard")
    def kubernetes_dashboard(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable the Kubernetes dashboard. Default `false` (bool)
        """
        return pulumi.get(self, "kubernetes_dashboard")

    @kubernetes_dashboard.setter
    def kubernetes_dashboard(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kubernetes_dashboard", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for cluster registration token object (map)
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[float]]:
        """
        The number of local SSD disks to be attached to the node. Default `0` (int)
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "local_ssd_count", value)

    @property
    @pulumi.getter(name="masterAuthorizedNetworkCidrBlocks")
    def master_authorized_network_cidr_blocks(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Define up to 10 external networks that could access Kubernetes master through HTTPS (list)
        """
        return pulumi.get(self, "master_authorized_network_cidr_blocks")

    @master_authorized_network_cidr_blocks.setter
    def master_authorized_network_cidr_blocks(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "master_authorized_network_cidr_blocks", value)

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> Optional[pulumi.Input[float]]:
        """
        Maximum number of nodes in the NodePool. Must be >= minNodeCount. There has to enough quota to scale up the cluster. Default `0` (int)
        """
        return pulumi.get(self, "max_node_count")

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_node_count", value)

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[pulumi.Input[float]]:
        """
        Minimmum number of nodes in the NodePool. Must be >= 1 and <= maxNodeCount. Default `0` (int)
        """
        return pulumi.get(self, "min_node_count")

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "min_node_count", value)

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[pulumi.Input[float]]:
        """
        Node count for GKE cluster. Default `3` (int)
        """
        return pulumi.get(self, "node_count")

    @node_count.setter
    def node_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "node_count", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. Default `false` (bool)
        """
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster region. Conflicts with `zone` (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="resourceLabels")
    def resource_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        The map of Kubernetes labels to be applied to each cluster (map)
        """
        return pulumi.get(self, "resource_labels")

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "resource_labels", value)

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        List of Kubernetes taints to be applied to each node (list)
        """
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "taints", value)

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether alias IPs will be used for pod IPs in the cluster. Default `false` (bool)
        """
        return pulumi.get(self, "use_ip_aliases")

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_ip_aliases", value)

    @property
    @pulumi.getter
    def zone(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster zone. Conflicts with `region` (string)
        """
        return pulumi.get(self, "zone")

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


@pulumi.input_type
class ClusterK3sConfigArgs:
    def __init__(__self__, *,
                 upgrade_strategy: Optional[pulumi.Input['ClusterK3sConfigUpgradeStrategyArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterK3sConfigUpgradeStrategyArgs'] upgrade_strategy: K3S upgrade strategy (List maxitems: 1)
        :param pulumi.Input[str] version: rancher-monitoring chart version (string)
        """
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional[pulumi.Input['ClusterK3sConfigUpgradeStrategyArgs']]:
        """
        K3S upgrade strategy (List maxitems: 1)
        """
        return pulumi.get(self, "upgrade_strategy")

    @upgrade_strategy.setter
    def upgrade_strategy(self, value: Optional[pulumi.Input['ClusterK3sConfigUpgradeStrategyArgs']]):
        pulumi.set(self, "upgrade_strategy", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        rancher-monitoring chart version (string)
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class ClusterK3sConfigUpgradeStrategyArgs:
    def __init__(__self__, *,
                 drain_server_nodes: Optional[pulumi.Input[bool]] = None,
                 drain_worker_nodes: Optional[pulumi.Input[bool]] = None,
                 server_concurrency: Optional[pulumi.Input[float]] = None,
                 worker_concurrency: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[bool] drain_server_nodes: Drain server nodes. Default: `false` (bool)
        :param pulumi.Input[bool] drain_worker_nodes: Drain worker nodes. Default: `false` (bool)
        :param pulumi.Input[float] server_concurrency: Server concurrency. Default: `1` (int)
        :param pulumi.Input[float] worker_concurrency: Worker concurrency. Default: `1` (int)
        """
        if drain_server_nodes is not None:
            pulumi.set(__self__, "drain_server_nodes", drain_server_nodes)
        if drain_worker_nodes is not None:
            pulumi.set(__self__, "drain_worker_nodes", drain_worker_nodes)
        if server_concurrency is not None:
            pulumi.set(__self__, "server_concurrency", server_concurrency)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)

    @property
    @pulumi.getter(name="drainServerNodes")
    def drain_server_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain server nodes. Default: `false` (bool)
        """
        return pulumi.get(self, "drain_server_nodes")

    @drain_server_nodes.setter
    def drain_server_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drain_server_nodes", value)

    @property
    @pulumi.getter(name="drainWorkerNodes")
    def drain_worker_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain worker nodes. Default: `false` (bool)
        """
        return pulumi.get(self, "drain_worker_nodes")

    @drain_worker_nodes.setter
    def drain_worker_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drain_worker_nodes", value)

    @property
    @pulumi.getter(name="serverConcurrency")
    def server_concurrency(self) -> Optional[pulumi.Input[float]]:
        """
        Server concurrency. Default: `1` (int)
        """
        return pulumi.get(self, "server_concurrency")

    @server_concurrency.setter
    def server_concurrency(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "server_concurrency", value)

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[pulumi.Input[float]]:
        """
        Worker concurrency. Default: `1` (int)
        """
        return pulumi.get(self, "worker_concurrency")

    @worker_concurrency.setter
    def worker_concurrency(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "worker_concurrency", value)


@pulumi.input_type
class ClusterLoggingCustomTargetConfigArgs:
    def __init__(__self__, *,
                 content: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content: Custom target config content (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        """
        pulumi.set(__self__, "content", content)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)

    @property
    @pulumi.getter
    def content(self) -> pulumi.Input[str]:
        """
        Custom target config content (string)
        """
        return pulumi.get(self, "content")

    @content.setter
    def content(self, value: pulumi.Input[str]):
        pulumi.set(self, "content", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)


@pulumi.input_type
class ClusterLoggingElasticsearchConfigArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 auth_password: Optional[pulumi.Input[str]] = None,
                 auth_username: Optional[pulumi.Input[str]] = None,
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 client_key_pass: Optional[pulumi.Input[str]] = None,
                 date_format: Optional[pulumi.Input[str]] = None,
                 index_prefix: Optional[pulumi.Input[str]] = None,
                 ssl_verify: Optional[pulumi.Input[bool]] = None,
                 ssl_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] auth_password: User password for the elascticsearch service (string)
        :param pulumi.Input[str] auth_username: Username for the elascticsearch service (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[str] client_key_pass: SSL client key password for the splunk service (string)
        :param pulumi.Input[str] date_format: Date format for the elascticsearch logs. Default: `YYYY-MM-DD` (string)
        :param pulumi.Input[str] index_prefix: Index prefix for the elascticsearch logs. Default: `local` (string)
        :param pulumi.Input[bool] ssl_verify: SSL verify for the syslog service (bool)
        :param pulumi.Input[str] ssl_version: SSL version for the elascticsearch service (string)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        if auth_password is not None:
            pulumi.set(__self__, "auth_password", auth_password)
        if auth_username is not None:
            pulumi.set(__self__, "auth_username", auth_username)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if date_format is not None:
            pulumi.set(__self__, "date_format", date_format)
        if index_prefix is not None:
            pulumi.set(__self__, "index_prefix", index_prefix)
        if ssl_verify is not None:
            pulumi.set(__self__, "ssl_verify", ssl_verify)
        if ssl_version is not None:
            pulumi.set(__self__, "ssl_version", ssl_version)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="authPassword")
    def auth_password(self) -> Optional[pulumi.Input[str]]:
        """
        User password for the elascticsearch service (string)
        """
        return pulumi.get(self, "auth_password")

    @auth_password.setter
    def auth_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_password", value)

    @property
    @pulumi.getter(name="authUsername")
    def auth_username(self) -> Optional[pulumi.Input[str]]:
        """
        Username for the elascticsearch service (string)
        """
        return pulumi.get(self, "auth_username")

    @auth_username.setter
    def auth_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_username", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key password for the splunk service (string)
        """
        return pulumi.get(self, "client_key_pass")

    @client_key_pass.setter
    def client_key_pass(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key_pass", value)

    @property
    @pulumi.getter(name="dateFormat")
    def date_format(self) -> Optional[pulumi.Input[str]]:
        """
        Date format for the elascticsearch logs. Default: `YYYY-MM-DD` (string)
        """
        return pulumi.get(self, "date_format")

    @date_format.setter
    def date_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_format", value)

    @property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        Index prefix for the elascticsearch logs. Default: `local` (string)
        """
        return pulumi.get(self, "index_prefix")

    @index_prefix.setter
    def index_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "index_prefix", value)

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        SSL verify for the syslog service (bool)
        """
        return pulumi.get(self, "ssl_verify")

    @ssl_verify.setter
    def ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl_verify", value)

    @property
    @pulumi.getter(name="sslVersion")
    def ssl_version(self) -> Optional[pulumi.Input[str]]:
        """
        SSL version for the elascticsearch service (string)
        """
        return pulumi.get(self, "ssl_version")

    @ssl_version.setter
    def ssl_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssl_version", value)


@pulumi.input_type
class ClusterLoggingFluentdConfigArgs:
    def __init__(__self__, *,
                 fluent_servers: pulumi.Input[List[pulumi.Input['ClusterLoggingFluentdConfigFluentServerArgs']]],
                 certificate: Optional[pulumi.Input[str]] = None,
                 compress: Optional[pulumi.Input[bool]] = None,
                 enable_tls: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[List[pulumi.Input['ClusterLoggingFluentdConfigFluentServerArgs']]] fluent_servers: Servers for the fluentd service (list)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[bool] compress: Compress data for the fluentd service (bool)
        :param pulumi.Input[bool] enable_tls: Enable TLS for the syslog service. Default `false` (bool)
        """
        pulumi.set(__self__, "fluent_servers", fluent_servers)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)

    @property
    @pulumi.getter(name="fluentServers")
    def fluent_servers(self) -> pulumi.Input[List[pulumi.Input['ClusterLoggingFluentdConfigFluentServerArgs']]]:
        """
        Servers for the fluentd service (list)
        """
        return pulumi.get(self, "fluent_servers")

    @fluent_servers.setter
    def fluent_servers(self, value: pulumi.Input[List[pulumi.Input['ClusterLoggingFluentdConfigFluentServerArgs']]]):
        pulumi.set(self, "fluent_servers", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter
    def compress(self) -> Optional[pulumi.Input[bool]]:
        """
        Compress data for the fluentd service (bool)
        """
        return pulumi.get(self, "compress")

    @compress.setter
    def compress(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "compress", value)

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable TLS for the syslog service. Default `false` (bool)
        """
        return pulumi.get(self, "enable_tls")

    @enable_tls.setter
    def enable_tls(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_tls", value)


@pulumi.input_type
class ClusterLoggingFluentdConfigFluentServerArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 hostname: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 shared_key: Optional[pulumi.Input[str]] = None,
                 standby: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] hostname: Hostname of the fluentd service (string)
        :param pulumi.Input[str] password: User password of the fluentd service (string)
        :param pulumi.Input[str] shared_key: Shared key of the fluentd service (string)
        :param pulumi.Input[bool] standby: Standby server of the fluentd service (bool)
        :param pulumi.Input[str] username: Username of the fluentd service (string)
        :param pulumi.Input[float] weight: Weight of the fluentd server (int)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if shared_key is not None:
            pulumi.set(__self__, "shared_key", shared_key)
        if standby is not None:
            pulumi.set(__self__, "standby", standby)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[str]]:
        """
        Hostname of the fluentd service (string)
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        User password of the fluentd service (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter(name="sharedKey")
    def shared_key(self) -> Optional[pulumi.Input[str]]:
        """
        Shared key of the fluentd service (string)
        """
        return pulumi.get(self, "shared_key")

    @shared_key.setter
    def shared_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "shared_key", value)

    @property
    @pulumi.getter
    def standby(self) -> Optional[pulumi.Input[bool]]:
        """
        Standby server of the fluentd service (bool)
        """
        return pulumi.get(self, "standby")

    @standby.setter
    def standby(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "standby", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        Username of the fluentd service (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[float]]:
        """
        Weight of the fluentd server (int)
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class ClusterLoggingKafkaConfigArgs:
    def __init__(__self__, *,
                 topic: pulumi.Input[str],
                 broker_endpoints: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 zookeeper_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] topic: Topic to publish on the kafka service (string)
        :param pulumi.Input[List[pulumi.Input[str]]] broker_endpoints: Kafka endpoints for kafka service. Conflicts with `zookeeper_endpoint` (list)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[str] zookeeper_endpoint: Zookeeper endpoint for kafka service. Conflicts with `broker_endpoints` (string)
        """
        pulumi.set(__self__, "topic", topic)
        if broker_endpoints is not None:
            pulumi.set(__self__, "broker_endpoints", broker_endpoints)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if zookeeper_endpoint is not None:
            pulumi.set(__self__, "zookeeper_endpoint", zookeeper_endpoint)

    @property
    @pulumi.getter
    def topic(self) -> pulumi.Input[str]:
        """
        Topic to publish on the kafka service (string)
        """
        return pulumi.get(self, "topic")

    @topic.setter
    def topic(self, value: pulumi.Input[str]):
        pulumi.set(self, "topic", value)

    @property
    @pulumi.getter(name="brokerEndpoints")
    def broker_endpoints(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Kafka endpoints for kafka service. Conflicts with `zookeeper_endpoint` (list)
        """
        return pulumi.get(self, "broker_endpoints")

    @broker_endpoints.setter
    def broker_endpoints(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "broker_endpoints", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="zookeeperEndpoint")
    def zookeeper_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Zookeeper endpoint for kafka service. Conflicts with `broker_endpoints` (string)
        """
        return pulumi.get(self, "zookeeper_endpoint")

    @zookeeper_endpoint.setter
    def zookeeper_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zookeeper_endpoint", value)


@pulumi.input_type
class ClusterLoggingSplunkConfigArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 token: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 client_key_pass: Optional[pulumi.Input[str]] = None,
                 index: Optional[pulumi.Input[str]] = None,
                 source: Optional[pulumi.Input[str]] = None,
                 ssl_verify: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] token: Token for the syslog service (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[str] client_key_pass: SSL client key password for the splunk service (string)
        :param pulumi.Input[str] index: Index prefix for the splunk logs (string)
        :param pulumi.Input[str] source: Date format for the splunk logs (string)
        :param pulumi.Input[bool] ssl_verify: SSL verify for the syslog service (bool)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "token", token)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if index is not None:
            pulumi.set(__self__, "index", index)
        if source is not None:
            pulumi.set(__self__, "source", source)
        if ssl_verify is not None:
            pulumi.set(__self__, "ssl_verify", ssl_verify)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def token(self) -> pulumi.Input[str]:
        """
        Token for the syslog service (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: pulumi.Input[str]):
        pulumi.set(self, "token", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key password for the splunk service (string)
        """
        return pulumi.get(self, "client_key_pass")

    @client_key_pass.setter
    def client_key_pass(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key_pass", value)

    @property
    @pulumi.getter
    def index(self) -> Optional[pulumi.Input[str]]:
        """
        Index prefix for the splunk logs (string)
        """
        return pulumi.get(self, "index")

    @index.setter
    def index(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "index", value)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        """
        Date format for the splunk logs (string)
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        SSL verify for the syslog service (bool)
        """
        return pulumi.get(self, "ssl_verify")

    @ssl_verify.setter
    def ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl_verify", value)


@pulumi.input_type
class ClusterLoggingSyslogConfigArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 enable_tls: Optional[pulumi.Input[bool]] = None,
                 program: Optional[pulumi.Input[str]] = None,
                 protocol: Optional[pulumi.Input[str]] = None,
                 severity: Optional[pulumi.Input[str]] = None,
                 ssl_verify: Optional[pulumi.Input[bool]] = None,
                 token: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[bool] enable_tls: Enable TLS for the syslog service. Default `false` (bool)
        :param pulumi.Input[str] program: Program for the syslog service (string)
        :param pulumi.Input[str] protocol: Protocol for the syslog service. `tcp` and `udp` are supported. Default: `udp` (string)
        :param pulumi.Input[str] severity: Date format for the syslog logs. `emergency`, `alert`, `critical`, `error`, `warning`, `notice`, `info` and `debug` are supported. Default: `notice` (string)
        :param pulumi.Input[bool] ssl_verify: SSL verify for the syslog service (bool)
        :param pulumi.Input[str] token: Token for the syslog service (string)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)
        if program is not None:
            pulumi.set(__self__, "program", program)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if ssl_verify is not None:
            pulumi.set(__self__, "ssl_verify", ssl_verify)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable TLS for the syslog service. Default `false` (bool)
        """
        return pulumi.get(self, "enable_tls")

    @enable_tls.setter
    def enable_tls(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_tls", value)

    @property
    @pulumi.getter
    def program(self) -> Optional[pulumi.Input[str]]:
        """
        Program for the syslog service (string)
        """
        return pulumi.get(self, "program")

    @program.setter
    def program(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "program", value)

    @property
    @pulumi.getter
    def protocol(self) -> Optional[pulumi.Input[str]]:
        """
        Protocol for the syslog service. `tcp` and `udp` are supported. Default: `udp` (string)
        """
        return pulumi.get(self, "protocol")

    @protocol.setter
    def protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol", value)

    @property
    @pulumi.getter
    def severity(self) -> Optional[pulumi.Input[str]]:
        """
        Date format for the syslog logs. `emergency`, `alert`, `critical`, `error`, `warning`, `notice`, `info` and `debug` are supported. Default: `notice` (string)
        """
        return pulumi.get(self, "severity")

    @severity.setter
    def severity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "severity", value)

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        SSL verify for the syslog service (bool)
        """
        return pulumi.get(self, "ssl_verify")

    @ssl_verify.setter
    def ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl_verify", value)

    @property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[str]]:
        """
        Token for the syslog service (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token", value)


@pulumi.input_type
class ClusterRkeConfigArgs:
    def __init__(__self__, *,
                 addon_job_timeout: Optional[pulumi.Input[float]] = None,
                 addons: Optional[pulumi.Input[str]] = None,
                 addons_includes: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 authentication: Optional[pulumi.Input['ClusterRkeConfigAuthenticationArgs']] = None,
                 authorization: Optional[pulumi.Input['ClusterRkeConfigAuthorizationArgs']] = None,
                 bastion_host: Optional[pulumi.Input['ClusterRkeConfigBastionHostArgs']] = None,
                 cloud_provider: Optional[pulumi.Input['ClusterRkeConfigCloudProviderArgs']] = None,
                 dns: Optional[pulumi.Input['ClusterRkeConfigDnsArgs']] = None,
                 ignore_docker_version: Optional[pulumi.Input[bool]] = None,
                 ingress: Optional[pulumi.Input['ClusterRkeConfigIngressArgs']] = None,
                 kubernetes_version: Optional[pulumi.Input[str]] = None,
                 monitoring: Optional[pulumi.Input['ClusterRkeConfigMonitoringArgs']] = None,
                 network: Optional[pulumi.Input['ClusterRkeConfigNetworkArgs']] = None,
                 nodes: Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigNodeArgs']]]] = None,
                 prefix_path: Optional[pulumi.Input[str]] = None,
                 private_registries: Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigPrivateRegistryArgs']]]] = None,
                 services: Optional[pulumi.Input['ClusterRkeConfigServicesArgs']] = None,
                 ssh_agent_auth: Optional[pulumi.Input[bool]] = None,
                 ssh_cert_path: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None,
                 upgrade_strategy: Optional[pulumi.Input['ClusterRkeConfigUpgradeStrategyArgs']] = None):
        """
        :param pulumi.Input[float] addon_job_timeout: Duration in seconds of addon job (int)
        :param pulumi.Input[str] addons: Addons descripton to deploy on RKE cluster.
        :param pulumi.Input[List[pulumi.Input[str]]] addons_includes: Addons yaml manifests to deploy on RKE cluster (list)
        :param pulumi.Input['ClusterRkeConfigAuthenticationArgs'] authentication: Kubernetes cluster authentication (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigAuthorizationArgs'] authorization: Kubernetes cluster authorization (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigBastionHostArgs'] bastion_host: RKE bastion host (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderArgs'] cloud_provider: RKE options for Calico network provider (string)
        :param pulumi.Input['ClusterRkeConfigDnsArgs'] dns: RKE dns add-on. Just for Rancher v2.2.x (list maxitems:1)
        :param pulumi.Input[bool] ignore_docker_version: Ignore docker version. Default `true` (bool)
        :param pulumi.Input['ClusterRkeConfigIngressArgs'] ingress: Kubernetes ingress configuration (list maxitems:1)
        :param pulumi.Input[str] kubernetes_version: The Kubernetes master version (string)
        :param pulumi.Input['ClusterRkeConfigMonitoringArgs'] monitoring: Kubernetes cluster monitoring (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigNetworkArgs'] network: Network for GKE cluster (string)
        :param pulumi.Input[List[pulumi.Input['ClusterRkeConfigNodeArgs']]] nodes: RKE cluster nodes (list)
        :param pulumi.Input[str] prefix_path: Prefix to customize Kubernetes path (string)
        :param pulumi.Input[List[pulumi.Input['ClusterRkeConfigPrivateRegistryArgs']]] private_registries: private registries for docker images (list)
        :param pulumi.Input['ClusterRkeConfigServicesArgs'] services: Kubernetes cluster services (list maxitems:1)
        :param pulumi.Input[bool] ssh_agent_auth: Use ssh agent auth. Default `false` (bool)
        :param pulumi.Input[str] ssh_cert_path: Cluster level SSH certificate path (string)
        :param pulumi.Input[str] ssh_key_path: Node SSH private key path (string)
        :param pulumi.Input['ClusterRkeConfigUpgradeStrategyArgs'] upgrade_strategy: K3S upgrade strategy (List maxitems: 1)
        """
        if addon_job_timeout is not None:
            pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if bastion_host is not None:
            pulumi.set(__self__, "bastion_host", bastion_host)
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter(name="addonJobTimeout")
    def addon_job_timeout(self) -> Optional[pulumi.Input[float]]:
        """
        Duration in seconds of addon job (int)
        """
        return pulumi.get(self, "addon_job_timeout")

    @addon_job_timeout.setter
    def addon_job_timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "addon_job_timeout", value)

    @property
    @pulumi.getter
    def addons(self) -> Optional[pulumi.Input[str]]:
        """
        Addons descripton to deploy on RKE cluster.
        """
        return pulumi.get(self, "addons")

    @addons.setter
    def addons(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "addons", value)

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Addons yaml manifests to deploy on RKE cluster (list)
        """
        return pulumi.get(self, "addons_includes")

    @addons_includes.setter
    def addons_includes(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "addons_includes", value)

    @property
    @pulumi.getter
    def authentication(self) -> Optional[pulumi.Input['ClusterRkeConfigAuthenticationArgs']]:
        """
        Kubernetes cluster authentication (list maxitems:1)
        """
        return pulumi.get(self, "authentication")

    @authentication.setter
    def authentication(self, value: Optional[pulumi.Input['ClusterRkeConfigAuthenticationArgs']]):
        pulumi.set(self, "authentication", value)

    @property
    @pulumi.getter
    def authorization(self) -> Optional[pulumi.Input['ClusterRkeConfigAuthorizationArgs']]:
        """
        Kubernetes cluster authorization (list maxitems:1)
        """
        return pulumi.get(self, "authorization")

    @authorization.setter
    def authorization(self, value: Optional[pulumi.Input['ClusterRkeConfigAuthorizationArgs']]):
        pulumi.set(self, "authorization", value)

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> Optional[pulumi.Input['ClusterRkeConfigBastionHostArgs']]:
        """
        RKE bastion host (list maxitems:1)
        """
        return pulumi.get(self, "bastion_host")

    @bastion_host.setter
    def bastion_host(self, value: Optional[pulumi.Input['ClusterRkeConfigBastionHostArgs']]):
        pulumi.set(self, "bastion_host", value)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderArgs']]:
        """
        RKE options for Calico network provider (string)
        """
        return pulumi.get(self, "cloud_provider")

    @cloud_provider.setter
    def cloud_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderArgs']]):
        pulumi.set(self, "cloud_provider", value)

    @property
    @pulumi.getter
    def dns(self) -> Optional[pulumi.Input['ClusterRkeConfigDnsArgs']]:
        """
        RKE dns add-on. Just for Rancher v2.2.x (list maxitems:1)
        """
        return pulumi.get(self, "dns")

    @dns.setter
    def dns(self, value: Optional[pulumi.Input['ClusterRkeConfigDnsArgs']]):
        pulumi.set(self, "dns", value)

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[pulumi.Input[bool]]:
        """
        Ignore docker version. Default `true` (bool)
        """
        return pulumi.get(self, "ignore_docker_version")

    @ignore_docker_version.setter
    def ignore_docker_version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_docker_version", value)

    @property
    @pulumi.getter
    def ingress(self) -> Optional[pulumi.Input['ClusterRkeConfigIngressArgs']]:
        """
        Kubernetes ingress configuration (list maxitems:1)
        """
        return pulumi.get(self, "ingress")

    @ingress.setter
    def ingress(self, value: Optional[pulumi.Input['ClusterRkeConfigIngressArgs']]):
        pulumi.set(self, "ingress", value)

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
        """
        The Kubernetes master version (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @kubernetes_version.setter
    def kubernetes_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kubernetes_version", value)

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input['ClusterRkeConfigMonitoringArgs']]:
        """
        Kubernetes cluster monitoring (list maxitems:1)
        """
        return pulumi.get(self, "monitoring")

    @monitoring.setter
    def monitoring(self, value: Optional[pulumi.Input['ClusterRkeConfigMonitoringArgs']]):
        pulumi.set(self, "monitoring", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkArgs']]:
        """
        Network for GKE cluster (string)
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['ClusterRkeConfigNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter
    def nodes(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigNodeArgs']]]]:
        """
        RKE cluster nodes (list)
        """
        return pulumi.get(self, "nodes")

    @nodes.setter
    def nodes(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigNodeArgs']]]]):
        pulumi.set(self, "nodes", value)

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> Optional[pulumi.Input[str]]:
        """
        Prefix to customize Kubernetes path (string)
        """
        return pulumi.get(self, "prefix_path")

    @prefix_path.setter
    def prefix_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_path", value)

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigPrivateRegistryArgs']]]]:
        """
        private registries for docker images (list)
        """
        return pulumi.get(self, "private_registries")

    @private_registries.setter
    def private_registries(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigPrivateRegistryArgs']]]]):
        pulumi.set(self, "private_registries", value)

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesArgs']]:
        """
        Kubernetes cluster services (list maxitems:1)
        """
        return pulumi.get(self, "services")

    @services.setter
    def services(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesArgs']]):
        pulumi.set(self, "services", value)

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[pulumi.Input[bool]]:
        """
        Use ssh agent auth. Default `false` (bool)
        """
        return pulumi.get(self, "ssh_agent_auth")

    @ssh_agent_auth.setter
    def ssh_agent_auth(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssh_agent_auth", value)

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster level SSH certificate path (string)
        """
        return pulumi.get(self, "ssh_cert_path")

    @ssh_cert_path.setter
    def ssh_cert_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_cert_path", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        """
        Node SSH private key path (string)
        """
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional[pulumi.Input['ClusterRkeConfigUpgradeStrategyArgs']]:
        """
        K3S upgrade strategy (List maxitems: 1)
        """
        return pulumi.get(self, "upgrade_strategy")

    @upgrade_strategy.setter
    def upgrade_strategy(self, value: Optional[pulumi.Input['ClusterRkeConfigUpgradeStrategyArgs']]):
        pulumi.set(self, "upgrade_strategy", value)


@pulumi.input_type
class ClusterRkeConfigAuthenticationArgs:
    def __init__(__self__, *,
                 sans: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[List[pulumi.Input[str]]] sans: RKE sans for authentication ([]string)
        :param pulumi.Input[str] strategy: Monitoring deployment update strategy (string)
        """
        if sans is not None:
            pulumi.set(__self__, "sans", sans)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        RKE sans for authentication ([]string)
        """
        return pulumi.get(self, "sans")

    @sans.setter
    def sans(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "sans", value)

    @property
    @pulumi.getter
    def strategy(self) -> Optional[pulumi.Input[str]]:
        """
        Monitoring deployment update strategy (string)
        """
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "strategy", value)


@pulumi.input_type
class ClusterRkeConfigAuthorizationArgs:
    def __init__(__self__, *,
                 mode: Optional[pulumi.Input[str]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] mode: RKE mode for authorization. `rbac` and `none` modes are available. Default `rbac` (string)
        :param pulumi.Input[Mapping[str, Any]] options: RKE options for network (map)
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if options is not None:
            pulumi.set(__self__, "options", options)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        RKE mode for authorization. `rbac` and `none` modes are available. Default `rbac` (string)
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE options for network (map)
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)


@pulumi.input_type
class ClusterRkeConfigBastionHostArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 user: pulumi.Input[str],
                 port: Optional[pulumi.Input[str]] = None,
                 ssh_agent_auth: Optional[pulumi.Input[bool]] = None,
                 ssh_key: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] address: Address ip for node (string)
        :param pulumi.Input[str] user: Registry user (string)
        :param pulumi.Input[str] port: Port for node. Default `22` (string)
        :param pulumi.Input[bool] ssh_agent_auth: Use ssh agent auth. Default `false` (bool)
        :param pulumi.Input[str] ssh_key: Node SSH private key (string)
        :param pulumi.Input[str] ssh_key_path: Node SSH private key path (string)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        """
        Address ip for node (string)
        """
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        """
        Registry user (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        """
        Port for node. Default `22` (string)
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[pulumi.Input[bool]]:
        """
        Use ssh agent auth. Default `false` (bool)
        """
        return pulumi.get(self, "ssh_agent_auth")

    @ssh_agent_auth.setter
    def ssh_agent_auth(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssh_agent_auth", value)

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[pulumi.Input[str]]:
        """
        Node SSH private key (string)
        """
        return pulumi.get(self, "ssh_key")

    @ssh_key.setter
    def ssh_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        """
        Node SSH private key path (string)
        """
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderArgs:
    def __init__(__self__, *,
                 aws_cloud_provider: Optional[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderArgs']] = None,
                 azure_cloud_provider: Optional[pulumi.Input['ClusterRkeConfigCloudProviderAzureCloudProviderArgs']] = None,
                 custom_cloud_provider: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 openstack_cloud_provider: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs']] = None,
                 vsphere_cloud_provider: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderArgs']] = None):
        """
        :param pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderArgs'] aws_cloud_provider: RKE AWS Cloud Provider config for Cloud Provider [rke-aws-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/aws/) (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderAzureCloudProviderArgs'] azure_cloud_provider: RKE Azure Cloud Provider config for Cloud Provider [rke-azure-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/azure/) (list maxitems:1)
        :param pulumi.Input[str] custom_cloud_provider: RKE Custom Cloud Provider config for Cloud Provider (string)
        :param pulumi.Input[str] name: Name of cluster registration token (string)
        :param pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs'] openstack_cloud_provider: RKE Openstack Cloud Provider config for Cloud Provider [rke-openstack-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/openstack/) (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderArgs'] vsphere_cloud_provider: RKE Vsphere Cloud Provider config for Cloud Provider [rke-vsphere-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/vsphere/) Extra argument `name` is required on `virtual_center` configuration. (list maxitems:1)
        """
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if custom_cloud_provider is not None:
            pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderArgs']]:
        """
        RKE AWS Cloud Provider config for Cloud Provider [rke-aws-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/aws/) (list maxitems:1)
        """
        return pulumi.get(self, "aws_cloud_provider")

    @aws_cloud_provider.setter
    def aws_cloud_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderArgs']]):
        pulumi.set(self, "aws_cloud_provider", value)

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderAzureCloudProviderArgs']]:
        """
        RKE Azure Cloud Provider config for Cloud Provider [rke-azure-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/azure/) (list maxitems:1)
        """
        return pulumi.get(self, "azure_cloud_provider")

    @azure_cloud_provider.setter
    def azure_cloud_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderAzureCloudProviderArgs']]):
        pulumi.set(self, "azure_cloud_provider", value)

    @property
    @pulumi.getter(name="customCloudProvider")
    def custom_cloud_provider(self) -> Optional[pulumi.Input[str]]:
        """
        RKE Custom Cloud Provider config for Cloud Provider (string)
        """
        return pulumi.get(self, "custom_cloud_provider")

    @custom_cloud_provider.setter
    def custom_cloud_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_cloud_provider", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of cluster registration token (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs']]:
        """
        RKE Openstack Cloud Provider config for Cloud Provider [rke-openstack-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/openstack/) (list maxitems:1)
        """
        return pulumi.get(self, "openstack_cloud_provider")

    @openstack_cloud_provider.setter
    def openstack_cloud_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs']]):
        pulumi.set(self, "openstack_cloud_provider", value)

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderArgs']]:
        """
        RKE Vsphere Cloud Provider config for Cloud Provider [rke-vsphere-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/vsphere/) Extra argument `name` is required on `virtual_center` configuration. (list maxitems:1)
        """
        return pulumi.get(self, "vsphere_cloud_provider")

    @vsphere_cloud_provider.setter
    def vsphere_cloud_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderArgs']]):
        pulumi.set(self, "vsphere_cloud_provider", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderAwsCloudProviderArgs:
    def __init__(__self__, *,
                 global_: Optional[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs']] = None,
                 service_overrides: Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs'] global_: (list maxitems:1)
        :param pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]] service_overrides: (list)
        """
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if service_overrides is not None:
            pulumi.set(__self__, "service_overrides", service_overrides)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "global_")

    @global_.setter
    def global_(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs']]):
        pulumi.set(self, "global_", value)

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]]:
        """
        (list)
        """
        return pulumi.get(self, "service_overrides")

    @service_overrides.setter
    def service_overrides(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]]):
        pulumi.set(self, "service_overrides", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 disable_security_group_ingress: Optional[pulumi.Input[bool]] = None,
                 disable_strict_zone_check: Optional[pulumi.Input[bool]] = None,
                 elb_security_group: Optional[pulumi.Input[str]] = None,
                 kubernetes_cluster_id: Optional[pulumi.Input[str]] = None,
                 kubernetes_cluster_tag: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 route_table_id: Optional[pulumi.Input[str]] = None,
                 subnet_id: Optional[pulumi.Input[str]] = None,
                 vpc: Optional[pulumi.Input[str]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] disable_security_group_ingress: Default `false` (bool)
        :param pulumi.Input[bool] disable_strict_zone_check: Default `false` (bool)
        :param pulumi.Input[str] elb_security_group: (string)
        :param pulumi.Input[str] kubernetes_cluster_id: (string)
        :param pulumi.Input[str] kubernetes_cluster_tag: (string)
        :param pulumi.Input[str] role_arn: (string)
        :param pulumi.Input[str] route_table_id: (string)
        :param pulumi.Input[str] subnet_id: (string)
        :param pulumi.Input[str] vpc: (string)
        :param pulumi.Input[str] zone: GKE cluster zone. Conflicts with `region` (string)
        """
        if disable_security_group_ingress is not None:
            pulumi.set(__self__, "disable_security_group_ingress", disable_security_group_ingress)
        if disable_strict_zone_check is not None:
            pulumi.set(__self__, "disable_strict_zone_check", disable_strict_zone_check)
        if elb_security_group is not None:
            pulumi.set(__self__, "elb_security_group", elb_security_group)
        if kubernetes_cluster_id is not None:
            pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        if kubernetes_cluster_tag is not None:
            pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if route_table_id is not None:
            pulumi.set(__self__, "route_table_id", route_table_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[pulumi.Input[bool]]:
        """
        Default `false` (bool)
        """
        return pulumi.get(self, "disable_security_group_ingress")

    @disable_security_group_ingress.setter
    def disable_security_group_ingress(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_security_group_ingress", value)

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[pulumi.Input[bool]]:
        """
        Default `false` (bool)
        """
        return pulumi.get(self, "disable_strict_zone_check")

    @disable_strict_zone_check.setter
    def disable_strict_zone_check(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_strict_zone_check", value)

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "elb_security_group")

    @elb_security_group.setter
    def elb_security_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "elb_security_group", value)

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "kubernetes_cluster_id")

    @kubernetes_cluster_id.setter
    def kubernetes_cluster_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kubernetes_cluster_id", value)

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "kubernetes_cluster_tag")

    @kubernetes_cluster_tag.setter
    def kubernetes_cluster_tag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kubernetes_cluster_tag", value)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "route_table_id")

    @route_table_id.setter
    def route_table_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route_table_id", value)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "subnet_id")

    @subnet_id.setter
    def subnet_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_id", value)

    @property
    @pulumi.getter
    def vpc(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "vpc")

    @vpc.setter
    def vpc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc", value)

    @property
    @pulumi.getter
    def zone(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster zone. Conflicts with `region` (string)
        """
        return pulumi.get(self, "zone")

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs:
    def __init__(__self__, *,
                 service: pulumi.Input[str],
                 region: Optional[pulumi.Input[str]] = None,
                 signing_method: Optional[pulumi.Input[str]] = None,
                 signing_name: Optional[pulumi.Input[str]] = None,
                 signing_region: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] service: (string)
        :param pulumi.Input[str] region: GKE cluster region. Conflicts with `zone` (string)
        :param pulumi.Input[str] signing_method: (string)
        :param pulumi.Input[str] signing_name: (string)
        :param pulumi.Input[str] signing_region: (string)
        :param pulumi.Input[str] url: Registry URL (string)
        """
        pulumi.set(__self__, "service", service)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if signing_method is not None:
            pulumi.set(__self__, "signing_method", signing_method)
        if signing_name is not None:
            pulumi.set(__self__, "signing_name", signing_name)
        if signing_region is not None:
            pulumi.set(__self__, "signing_region", signing_region)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def service(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: pulumi.Input[str]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster region. Conflicts with `zone` (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "signing_method")

    @signing_method.setter
    def signing_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_method", value)

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "signing_name")

    @signing_name.setter
    def signing_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_name", value)

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "signing_region")

    @signing_region.setter
    def signing_region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_region", value)

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        """
        Registry URL (string)
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderAzureCloudProviderArgs:
    def __init__(__self__, *,
                 aad_client_id: pulumi.Input[str],
                 aad_client_secret: pulumi.Input[str],
                 subscription_id: pulumi.Input[str],
                 tenant_id: pulumi.Input[str],
                 aad_client_cert_password: Optional[pulumi.Input[str]] = None,
                 aad_client_cert_path: Optional[pulumi.Input[str]] = None,
                 cloud: Optional[pulumi.Input[str]] = None,
                 cloud_provider_backoff: Optional[pulumi.Input[bool]] = None,
                 cloud_provider_backoff_duration: Optional[pulumi.Input[float]] = None,
                 cloud_provider_backoff_exponent: Optional[pulumi.Input[float]] = None,
                 cloud_provider_backoff_jitter: Optional[pulumi.Input[float]] = None,
                 cloud_provider_backoff_retries: Optional[pulumi.Input[float]] = None,
                 cloud_provider_rate_limit: Optional[pulumi.Input[bool]] = None,
                 cloud_provider_rate_limit_bucket: Optional[pulumi.Input[float]] = None,
                 cloud_provider_rate_limit_qps: Optional[pulumi.Input[float]] = None,
                 load_balancer_sku: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 maximum_load_balancer_rule_count: Optional[pulumi.Input[float]] = None,
                 primary_availability_set_name: Optional[pulumi.Input[str]] = None,
                 primary_scale_set_name: Optional[pulumi.Input[str]] = None,
                 resource_group: Optional[pulumi.Input[str]] = None,
                 route_table_name: Optional[pulumi.Input[str]] = None,
                 security_group_name: Optional[pulumi.Input[str]] = None,
                 subnet_name: Optional[pulumi.Input[str]] = None,
                 use_instance_metadata: Optional[pulumi.Input[bool]] = None,
                 use_managed_identity_extension: Optional[pulumi.Input[bool]] = None,
                 vm_type: Optional[pulumi.Input[str]] = None,
                 vnet_name: Optional[pulumi.Input[str]] = None,
                 vnet_resource_group: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] aad_client_id: (string)
        :param pulumi.Input[str] aad_client_secret: (string)
        :param pulumi.Input[str] subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription (string)
        :param pulumi.Input[str] tenant_id: Azure tenant ID to use (string)
        :param pulumi.Input[str] aad_client_cert_password: (string)
        :param pulumi.Input[str] aad_client_cert_path: (string)
        :param pulumi.Input[str] cloud: (string)
        :param pulumi.Input[bool] cloud_provider_backoff: (bool)
        :param pulumi.Input[float] cloud_provider_backoff_duration: (int)
        :param pulumi.Input[float] cloud_provider_backoff_exponent: (int)
        :param pulumi.Input[float] cloud_provider_backoff_jitter: (int)
        :param pulumi.Input[float] cloud_provider_backoff_retries: (int)
        :param pulumi.Input[bool] cloud_provider_rate_limit: (bool)
        :param pulumi.Input[float] cloud_provider_rate_limit_bucket: (int)
        :param pulumi.Input[float] cloud_provider_rate_limit_qps: (int)
        :param pulumi.Input[str] load_balancer_sku: Allowed values: `basic` (default) `standard` (string)
        :param pulumi.Input[str] location: Azure Kubernetes cluster location. Default `eastus` (string)
        :param pulumi.Input[float] maximum_load_balancer_rule_count: (int)
        :param pulumi.Input[str] primary_availability_set_name: (string)
        :param pulumi.Input[str] primary_scale_set_name: (string)
        :param pulumi.Input[str] resource_group: The name of the Cluster resource group (string)
        :param pulumi.Input[str] route_table_name: (string)
        :param pulumi.Input[str] security_group_name: (string)
        :param pulumi.Input[str] subnet_name: (string)
        :param pulumi.Input[bool] use_instance_metadata: (bool)
        :param pulumi.Input[bool] use_managed_identity_extension: (bool)
        :param pulumi.Input[str] vm_type: (string)
        :param pulumi.Input[str] vnet_name: (string)
        :param pulumi.Input[str] vnet_resource_group: (string)
        """
        pulumi.set(__self__, "aad_client_id", aad_client_id)
        pulumi.set(__self__, "aad_client_secret", aad_client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if aad_client_cert_password is not None:
            pulumi.set(__self__, "aad_client_cert_password", aad_client_cert_password)
        if aad_client_cert_path is not None:
            pulumi.set(__self__, "aad_client_cert_path", aad_client_cert_path)
        if cloud is not None:
            pulumi.set(__self__, "cloud", cloud)
        if cloud_provider_backoff is not None:
            pulumi.set(__self__, "cloud_provider_backoff", cloud_provider_backoff)
        if cloud_provider_backoff_duration is not None:
            pulumi.set(__self__, "cloud_provider_backoff_duration", cloud_provider_backoff_duration)
        if cloud_provider_backoff_exponent is not None:
            pulumi.set(__self__, "cloud_provider_backoff_exponent", cloud_provider_backoff_exponent)
        if cloud_provider_backoff_jitter is not None:
            pulumi.set(__self__, "cloud_provider_backoff_jitter", cloud_provider_backoff_jitter)
        if cloud_provider_backoff_retries is not None:
            pulumi.set(__self__, "cloud_provider_backoff_retries", cloud_provider_backoff_retries)
        if cloud_provider_rate_limit is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit", cloud_provider_rate_limit)
        if cloud_provider_rate_limit_bucket is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_bucket", cloud_provider_rate_limit_bucket)
        if cloud_provider_rate_limit_qps is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_qps", cloud_provider_rate_limit_qps)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if maximum_load_balancer_rule_count is not None:
            pulumi.set(__self__, "maximum_load_balancer_rule_count", maximum_load_balancer_rule_count)
        if primary_availability_set_name is not None:
            pulumi.set(__self__, "primary_availability_set_name", primary_availability_set_name)
        if primary_scale_set_name is not None:
            pulumi.set(__self__, "primary_scale_set_name", primary_scale_set_name)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if route_table_name is not None:
            pulumi.set(__self__, "route_table_name", route_table_name)
        if security_group_name is not None:
            pulumi.set(__self__, "security_group_name", security_group_name)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)
        if use_instance_metadata is not None:
            pulumi.set(__self__, "use_instance_metadata", use_instance_metadata)
        if use_managed_identity_extension is not None:
            pulumi.set(__self__, "use_managed_identity_extension", use_managed_identity_extension)
        if vm_type is not None:
            pulumi.set(__self__, "vm_type", vm_type)
        if vnet_name is not None:
            pulumi.set(__self__, "vnet_name", vnet_name)
        if vnet_resource_group is not None:
            pulumi.set(__self__, "vnet_resource_group", vnet_resource_group)

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "aad_client_id")

    @aad_client_id.setter
    def aad_client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "aad_client_id", value)

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "aad_client_secret")

    @aad_client_secret.setter
    def aad_client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "aad_client_secret", value)

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> pulumi.Input[str]:
        """
        Subscription credentials which uniquely identify Microsoft Azure subscription (string)
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "subscription_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> pulumi.Input[str]:
        """
        Azure tenant ID to use (string)
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "tenant_id", value)

    @property
    @pulumi.getter(name="aadClientCertPassword")
    def aad_client_cert_password(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "aad_client_cert_password")

    @aad_client_cert_password.setter
    def aad_client_cert_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aad_client_cert_password", value)

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "aad_client_cert_path")

    @aad_client_cert_path.setter
    def aad_client_cert_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aad_client_cert_path", value)

    @property
    @pulumi.getter
    def cloud(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "cloud")

    @cloud.setter
    def cloud(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud", value)

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "cloud_provider_backoff")

    @cloud_provider_backoff.setter
    def cloud_provider_backoff(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "cloud_provider_backoff", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @cloud_provider_backoff_duration.setter
    def cloud_provider_backoff_duration(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_duration", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @cloud_provider_backoff_exponent.setter
    def cloud_provider_backoff_exponent(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_exponent", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @cloud_provider_backoff_jitter.setter
    def cloud_provider_backoff_jitter(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_jitter", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @cloud_provider_backoff_retries.setter
    def cloud_provider_backoff_retries(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_retries", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "cloud_provider_rate_limit")

    @cloud_provider_rate_limit.setter
    def cloud_provider_rate_limit(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "cloud_provider_rate_limit", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @cloud_provider_rate_limit_bucket.setter
    def cloud_provider_rate_limit_bucket(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_rate_limit_bucket", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @cloud_provider_rate_limit_qps.setter
    def cloud_provider_rate_limit_qps(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_rate_limit_qps", value)

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[pulumi.Input[str]]:
        """
        Allowed values: `basic` (default) `standard` (string)
        """
        return pulumi.get(self, "load_balancer_sku")

    @load_balancer_sku.setter
    def load_balancer_sku(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "load_balancer_sku", value)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Kubernetes cluster location. Default `eastus` (string)
        """
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @maximum_load_balancer_rule_count.setter
    def maximum_load_balancer_rule_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "maximum_load_balancer_rule_count", value)

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "primary_availability_set_name")

    @primary_availability_set_name.setter
    def primary_availability_set_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "primary_availability_set_name", value)

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "primary_scale_set_name")

    @primary_scale_set_name.setter
    def primary_scale_set_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "primary_scale_set_name", value)

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Cluster resource group (string)
        """
        return pulumi.get(self, "resource_group")

    @resource_group.setter
    def resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_group", value)

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "route_table_name")

    @route_table_name.setter
    def route_table_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route_table_name", value)

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "security_group_name")

    @security_group_name.setter
    def security_group_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "security_group_name", value)

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "subnet_name")

    @subnet_name.setter
    def subnet_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_name", value)

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "use_instance_metadata")

    @use_instance_metadata.setter
    def use_instance_metadata(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_instance_metadata", value)

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "use_managed_identity_extension")

    @use_managed_identity_extension.setter
    def use_managed_identity_extension(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_managed_identity_extension", value)

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "vm_type")

    @vm_type.setter
    def vm_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vm_type", value)

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "vnet_name")

    @vnet_name.setter
    def vnet_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vnet_name", value)

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "vnet_resource_group")

    @vnet_resource_group.setter
    def vnet_resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vnet_resource_group", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs:
    def __init__(__self__, *,
                 global_: pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs'],
                 block_storage: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs']] = None,
                 load_balancer: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs']] = None,
                 metadata: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs']] = None,
                 route: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs']] = None):
        """
        :param pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs'] global_: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs'] block_storage: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs'] load_balancer: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs'] metadata: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs'] route: (list maxitems:1)
        """
        pulumi.set(__self__, "global_", global_)
        if block_storage is not None:
            pulumi.set(__self__, "block_storage", block_storage)
        if load_balancer is not None:
            pulumi.set(__self__, "load_balancer", load_balancer)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if route is not None:
            pulumi.set(__self__, "route", route)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs']:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "global_")

    @global_.setter
    def global_(self, value: pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs']):
        pulumi.set(self, "global_", value)

    @property
    @pulumi.getter(name="blockStorage")
    def block_storage(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "block_storage")

    @block_storage.setter
    def block_storage(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs']]):
        pulumi.set(self, "block_storage", value)

    @property
    @pulumi.getter(name="loadBalancer")
    def load_balancer(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "load_balancer")

    @load_balancer.setter
    def load_balancer(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs']]):
        pulumi.set(self, "load_balancer", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs']]):
        pulumi.set(self, "metadata", value)

    @property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs']]):
        pulumi.set(self, "route", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs:
    def __init__(__self__, *,
                 bs_version: Optional[pulumi.Input[str]] = None,
                 ignore_volume_az: Optional[pulumi.Input[bool]] = None,
                 trust_device_path: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] bs_version: (string)
        :param pulumi.Input[bool] ignore_volume_az: (string)
        :param pulumi.Input[bool] trust_device_path: (string)
        """
        if bs_version is not None:
            pulumi.set(__self__, "bs_version", bs_version)
        if ignore_volume_az is not None:
            pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        if trust_device_path is not None:
            pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "bs_version")

    @bs_version.setter
    def bs_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bs_version", value)

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> Optional[pulumi.Input[bool]]:
        """
        (string)
        """
        return pulumi.get(self, "ignore_volume_az")

    @ignore_volume_az.setter
    def ignore_volume_az(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_volume_az", value)

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> Optional[pulumi.Input[bool]]:
        """
        (string)
        """
        return pulumi.get(self, "trust_device_path")

    @trust_device_path.setter
    def trust_device_path(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "trust_device_path", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 auth_url: pulumi.Input[str],
                 password: pulumi.Input[str],
                 username: pulumi.Input[str],
                 ca_file: Optional[pulumi.Input[str]] = None,
                 domain_id: Optional[pulumi.Input[str]] = None,
                 domain_name: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None,
                 tenant_name: Optional[pulumi.Input[str]] = None,
                 trust_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] auth_url: (string)
        :param pulumi.Input[str] password: Registry password (string)
        :param pulumi.Input[str] username: (string)
        :param pulumi.Input[str] ca_file: (string)
        :param pulumi.Input[str] domain_id: Required if `domain_name` not provided. (string)
        :param pulumi.Input[str] domain_name: Required if `domain_id` not provided. (string)
        :param pulumi.Input[str] region: GKE cluster region. Conflicts with `zone` (string)
        :param pulumi.Input[str] tenant_id: Azure tenant ID to use (string)
        :param pulumi.Input[str] tenant_name: Required if `tenant_id` not provided. (string)
        :param pulumi.Input[str] trust_id: (string)
        """
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if ca_file is not None:
            pulumi.set(__self__, "ca_file", ca_file)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if trust_id is not None:
            pulumi.set(__self__, "trust_id", trust_id)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "auth_url")

    @auth_url.setter
    def auth_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "auth_url", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        Registry password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "ca_file")

    @ca_file.setter
    def ca_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_file", value)

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[pulumi.Input[str]]:
        """
        Required if `domain_name` not provided. (string)
        """
        return pulumi.get(self, "domain_id")

    @domain_id.setter
    def domain_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_id", value)

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        Required if `domain_id` not provided. (string)
        """
        return pulumi.get(self, "domain_name")

    @domain_name.setter
    def domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_name", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster region. Conflicts with `zone` (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure tenant ID to use (string)
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[pulumi.Input[str]]:
        """
        Required if `tenant_id` not provided. (string)
        """
        return pulumi.get(self, "tenant_name")

    @tenant_name.setter
    def tenant_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_name", value)

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "trust_id")

    @trust_id.setter
    def trust_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "trust_id", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs:
    def __init__(__self__, *,
                 create_monitor: Optional[pulumi.Input[bool]] = None,
                 floating_network_id: Optional[pulumi.Input[str]] = None,
                 lb_method: Optional[pulumi.Input[str]] = None,
                 lb_provider: Optional[pulumi.Input[str]] = None,
                 lb_version: Optional[pulumi.Input[str]] = None,
                 manage_security_groups: Optional[pulumi.Input[bool]] = None,
                 monitor_delay: Optional[pulumi.Input[str]] = None,
                 monitor_max_retries: Optional[pulumi.Input[float]] = None,
                 monitor_timeout: Optional[pulumi.Input[str]] = None,
                 subnet_id: Optional[pulumi.Input[str]] = None,
                 use_octavia: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] create_monitor: (bool)
        :param pulumi.Input[str] floating_network_id: (string)
        :param pulumi.Input[str] lb_method: (string)
        :param pulumi.Input[str] lb_provider: (string)
        :param pulumi.Input[str] lb_version: (string)
        :param pulumi.Input[bool] manage_security_groups: (bool)
        :param pulumi.Input[str] monitor_delay: Default `60s` (string)
        :param pulumi.Input[float] monitor_max_retries: Default 5 (int)
        :param pulumi.Input[str] monitor_timeout: Default `30s` (string)
        :param pulumi.Input[str] subnet_id: (string)
        :param pulumi.Input[bool] use_octavia: (bool)
        """
        if create_monitor is not None:
            pulumi.set(__self__, "create_monitor", create_monitor)
        if floating_network_id is not None:
            pulumi.set(__self__, "floating_network_id", floating_network_id)
        if lb_method is not None:
            pulumi.set(__self__, "lb_method", lb_method)
        if lb_provider is not None:
            pulumi.set(__self__, "lb_provider", lb_provider)
        if lb_version is not None:
            pulumi.set(__self__, "lb_version", lb_version)
        if manage_security_groups is not None:
            pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        if monitor_delay is not None:
            pulumi.set(__self__, "monitor_delay", monitor_delay)
        if monitor_max_retries is not None:
            pulumi.set(__self__, "monitor_max_retries", monitor_max_retries)
        if monitor_timeout is not None:
            pulumi.set(__self__, "monitor_timeout", monitor_timeout)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if use_octavia is not None:
            pulumi.set(__self__, "use_octavia", use_octavia)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "create_monitor")

    @create_monitor.setter
    def create_monitor(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_monitor", value)

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "floating_network_id")

    @floating_network_id.setter
    def floating_network_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "floating_network_id", value)

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "lb_method")

    @lb_method.setter
    def lb_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lb_method", value)

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "lb_provider")

    @lb_provider.setter
    def lb_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lb_provider", value)

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "lb_version")

    @lb_version.setter
    def lb_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lb_version", value)

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "manage_security_groups")

    @manage_security_groups.setter
    def manage_security_groups(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "manage_security_groups", value)

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[pulumi.Input[str]]:
        """
        Default `60s` (string)
        """
        return pulumi.get(self, "monitor_delay")

    @monitor_delay.setter
    def monitor_delay(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "monitor_delay", value)

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[pulumi.Input[float]]:
        """
        Default 5 (int)
        """
        return pulumi.get(self, "monitor_max_retries")

    @monitor_max_retries.setter
    def monitor_max_retries(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "monitor_max_retries", value)

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        Default `30s` (string)
        """
        return pulumi.get(self, "monitor_timeout")

    @monitor_timeout.setter
    def monitor_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "monitor_timeout", value)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "subnet_id")

    @subnet_id.setter
    def subnet_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_id", value)

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "use_octavia")

    @use_octavia.setter
    def use_octavia(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_octavia", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs:
    def __init__(__self__, *,
                 request_timeout: Optional[pulumi.Input[float]] = None,
                 search_order: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] request_timeout: (int)
        :param pulumi.Input[str] search_order: (string)
        """
        if request_timeout is not None:
            pulumi.set(__self__, "request_timeout", request_timeout)
        if search_order is not None:
            pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "request_timeout")

    @request_timeout.setter
    def request_timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "request_timeout", value)

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "search_order")

    @search_order.setter
    def search_order(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "search_order", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs:
    def __init__(__self__, *,
                 router_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] router_id: (string)
        """
        if router_id is not None:
            pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "router_id")

    @router_id.setter
    def router_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "router_id", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderArgs:
    def __init__(__self__, *,
                 virtual_centers: pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]],
                 workspace: pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs'],
                 disk: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs']] = None,
                 global_: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs']] = None,
                 network: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs']] = None):
        """
        :param pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]] virtual_centers: (List)
        :param pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs'] workspace: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs'] disk: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs'] global_: (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs'] network: Network for GKE cluster (string)
        """
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if network is not None:
            pulumi.set(__self__, "network", network)

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]]:
        """
        (List)
        """
        return pulumi.get(self, "virtual_centers")

    @virtual_centers.setter
    def virtual_centers(self, value: pulumi.Input[List[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]]):
        pulumi.set(self, "virtual_centers", value)

    @property
    @pulumi.getter
    def workspace(self) -> pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs']:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "workspace")

    @workspace.setter
    def workspace(self, value: pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs']):
        pulumi.set(self, "workspace", value)

    @property
    @pulumi.getter
    def disk(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "disk")

    @disk.setter
    def disk(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs']]):
        pulumi.set(self, "disk", value)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "global_")

    @global_.setter
    def global_(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs']]):
        pulumi.set(self, "global_", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs']]:
        """
        Network for GKE cluster (string)
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs']]):
        pulumi.set(self, "network", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs:
    def __init__(__self__, *,
                 scsi_controller_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] scsi_controller_type: (string)
        """
        if scsi_controller_type is not None:
            pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "scsi_controller_type")

    @scsi_controller_type.setter
    def scsi_controller_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scsi_controller_type", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 datacenters: Optional[pulumi.Input[str]] = None,
                 insecure_flag: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[str]] = None,
                 soap_roundtrip_count: Optional[pulumi.Input[float]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] datacenters: (string)
        :param pulumi.Input[bool] insecure_flag: (bool)
        :param pulumi.Input[str] password: Registry password (string)
        :param pulumi.Input[str] port: Port for node. Default `22` (string)
        :param pulumi.Input[float] soap_roundtrip_count: (int)
        :param pulumi.Input[str] user: Registry user (string)
        """
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if insecure_flag is not None:
            pulumi.set(__self__, "insecure_flag", insecure_flag)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "datacenters")

    @datacenters.setter
    def datacenters(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datacenters", value)

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> Optional[pulumi.Input[bool]]:
        """
        (bool)
        """
        return pulumi.get(self, "insecure_flag")

    @insecure_flag.setter
    def insecure_flag(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "insecure_flag", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        Registry password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        """
        Port for node. Default `22` (string)
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "soap_roundtrip_count", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[str]]:
        """
        Registry user (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs:
    def __init__(__self__, *,
                 public_network: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] public_network: (string)
        """
        if public_network is not None:
            pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "public_network")

    @public_network.setter
    def public_network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_network", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs:
    def __init__(__self__, *,
                 datacenters: pulumi.Input[str],
                 name: pulumi.Input[str],
                 password: pulumi.Input[str],
                 user: pulumi.Input[str],
                 port: Optional[pulumi.Input[str]] = None,
                 soap_roundtrip_count: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] datacenters: (string)
        :param pulumi.Input[str] name: Name of cluster registration token (string)
        :param pulumi.Input[str] password: Registry password (string)
        :param pulumi.Input[str] user: Registry user (string)
        :param pulumi.Input[str] port: Port for node. Default `22` (string)
        :param pulumi.Input[float] soap_roundtrip_count: (int)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)

    @property
    @pulumi.getter
    def datacenters(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "datacenters")

    @datacenters.setter
    def datacenters(self, value: pulumi.Input[str]):
        pulumi.set(self, "datacenters", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Name of cluster registration token (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        Registry password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        """
        Registry user (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        """
        Port for node. Default `22` (string)
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[pulumi.Input[float]]:
        """
        (int)
        """
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "soap_roundtrip_count", value)


@pulumi.input_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs:
    def __init__(__self__, *,
                 datacenter: pulumi.Input[str],
                 folder: pulumi.Input[str],
                 server: pulumi.Input[str],
                 default_datastore: Optional[pulumi.Input[str]] = None,
                 resourcepool_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] datacenter: (string)
        :param pulumi.Input[str] folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param pulumi.Input[str] server: (string)
        :param pulumi.Input[str] default_datastore: (string)
        :param pulumi.Input[str] resourcepool_path: (string)
        """
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "server", server)
        if default_datastore is not None:
            pulumi.set(__self__, "default_datastore", default_datastore)
        if resourcepool_path is not None:
            pulumi.set(__self__, "resourcepool_path", resourcepool_path)

    @property
    @pulumi.getter
    def datacenter(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "datacenter")

    @datacenter.setter
    def datacenter(self, value: pulumi.Input[str]):
        pulumi.set(self, "datacenter", value)

    @property
    @pulumi.getter
    def folder(self) -> pulumi.Input[str]:
        """
        Folder for S3 service. Available from Rancher v2.2.7 (string)
        """
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: pulumi.Input[str]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter
    def server(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "server")

    @server.setter
    def server(self, value: pulumi.Input[str]):
        pulumi.set(self, "server", value)

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "default_datastore")

    @default_datastore.setter
    def default_datastore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_datastore", value)

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "resourcepool_path")

    @resourcepool_path.setter
    def resourcepool_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resourcepool_path", value)


@pulumi.input_type
class ClusterRkeConfigDnsArgs:
    def __init__(__self__, *,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 nodelocal: Optional[pulumi.Input['ClusterRkeConfigDnsNodelocalArgs']] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 reverse_cidrs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 upstream_nameservers: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] node_selector: RKE monitoring node selector (map)
        :param pulumi.Input['ClusterRkeConfigDnsNodelocalArgs'] nodelocal: Nodelocal dns config  (list Maxitem: 1)
        :param pulumi.Input[str] provider: RKE monitoring provider (string)
        :param pulumi.Input[List[pulumi.Input[str]]] reverse_cidrs: DNS add-on reverse cidr  (list)
        :param pulumi.Input[List[pulumi.Input[str]]] upstream_nameservers: DNS add-on upstream nameservers  (list)
        """
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional[pulumi.Input['ClusterRkeConfigDnsNodelocalArgs']]:
        """
        Nodelocal dns config  (list Maxitem: 1)
        """
        return pulumi.get(self, "nodelocal")

    @nodelocal.setter
    def nodelocal(self, value: Optional[pulumi.Input['ClusterRkeConfigDnsNodelocalArgs']]):
        pulumi.set(self, "nodelocal", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input[str]]:
        """
        RKE monitoring provider (string)
        """
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provider", value)

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        DNS add-on reverse cidr  (list)
        """
        return pulumi.get(self, "reverse_cidrs")

    @reverse_cidrs.setter
    def reverse_cidrs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "reverse_cidrs", value)

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        DNS add-on upstream nameservers  (list)
        """
        return pulumi.get(self, "upstream_nameservers")

    @upstream_nameservers.setter
    def upstream_nameservers(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "upstream_nameservers", value)


@pulumi.input_type
class ClusterRkeConfigDnsNodelocalArgs:
    def __init__(__self__, *,
                 ip_address: Optional[pulumi.Input[str]] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] ip_address: Nodelocal dns ip address (string)
        :param pulumi.Input[Mapping[str, Any]] node_selector: RKE monitoring node selector (map)
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        Nodelocal dns ip address (string)
        """
        return pulumi.get(self, "ip_address")

    @ip_address.setter
    def ip_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ip_address", value)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)


@pulumi.input_type
class ClusterRkeConfigIngressArgs:
    def __init__(__self__, *,
                 dns_policy: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] dns_policy: Ingress controller DNS policy. `ClusterFirstWithHostNet`, `ClusterFirst`, `Default`, and `None` are supported. [K8S dns Policy](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy) (string)
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[Mapping[str, Any]] node_selector: RKE monitoring node selector (map)
        :param pulumi.Input[Mapping[str, Any]] options: RKE options for network (map)
        :param pulumi.Input[str] provider: RKE monitoring provider (string)
        """
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Ingress controller DNS policy. `ClusterFirstWithHostNet`, `ClusterFirst`, `Default`, and `None` are supported. [K8S dns Policy](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy) (string)
        """
        return pulumi.get(self, "dns_policy")

    @dns_policy.setter
    def dns_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dns_policy", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE options for network (map)
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input[str]]:
        """
        RKE monitoring provider (string)
        """
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provider", value)


@pulumi.input_type
class ClusterRkeConfigMonitoringArgs:
    def __init__(__self__, *,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 replicas: Optional[pulumi.Input[float]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs']] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] node_selector: RKE monitoring node selector (map)
        :param pulumi.Input[Mapping[str, Any]] options: RKE options for network (map)
        :param pulumi.Input[str] provider: RKE monitoring provider (string)
        :param pulumi.Input[float] replicas: RKE monitoring replicas (int)
        :param pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs'] update_strategy: RKE monitoring update strategy (list Maxitems: 1)
        """
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE options for network (map)
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input[str]]:
        """
        RKE monitoring provider (string)
        """
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provider", value)

    @property
    @pulumi.getter
    def replicas(self) -> Optional[pulumi.Input[float]]:
        """
        RKE monitoring replicas (int)
        """
        return pulumi.get(self, "replicas")

    @replicas.setter
    def replicas(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "replicas", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs']]:
        """
        RKE monitoring update strategy (list Maxitems: 1)
        """
        return pulumi.get(self, "update_strategy")

    @update_strategy.setter
    def update_strategy(self, value: Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs']]):
        pulumi.set(self, "update_strategy", value)


@pulumi.input_type
class ClusterRkeConfigMonitoringUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs'] rolling_update: Monitoring deployment rolling update (list Maxitems: 1)
        :param pulumi.Input[str] strategy: Monitoring deployment update strategy (string)
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']]:
        """
        Monitoring deployment rolling update (list Maxitems: 1)
        """
        return pulumi.get(self, "rolling_update")

    @rolling_update.setter
    def rolling_update(self, value: Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']]):
        pulumi.set(self, "rolling_update", value)

    @property
    @pulumi.getter
    def strategy(self) -> Optional[pulumi.Input[str]]:
        """
        Monitoring deployment update strategy (string)
        """
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "strategy", value)


@pulumi.input_type
class ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_surge: Optional[pulumi.Input[float]] = None,
                 max_unavailable: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[float] max_surge: Monitoring deployment rolling update max surge. Default: `1` (int)
        :param pulumi.Input[float] max_unavailable: Monitoring deployment rolling update max unavailable. Default: `1` (int)
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[pulumi.Input[float]]:
        """
        Monitoring deployment rolling update max surge. Default: `1` (int)
        """
        return pulumi.get(self, "max_surge")

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_surge", value)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[float]]:
        """
        Monitoring deployment rolling update max unavailable. Default: `1` (int)
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_unavailable", value)


@pulumi.input_type
class ClusterRkeConfigNetworkArgs:
    def __init__(__self__, *,
                 calico_network_provider: Optional[pulumi.Input['ClusterRkeConfigNetworkCalicoNetworkProviderArgs']] = None,
                 canal_network_provider: Optional[pulumi.Input['ClusterRkeConfigNetworkCanalNetworkProviderArgs']] = None,
                 flannel_network_provider: Optional[pulumi.Input['ClusterRkeConfigNetworkFlannelNetworkProviderArgs']] = None,
                 mtu: Optional[pulumi.Input[float]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 plugin: Optional[pulumi.Input[str]] = None,
                 weave_network_provider: Optional[pulumi.Input['ClusterRkeConfigNetworkWeaveNetworkProviderArgs']] = None):
        """
        :param pulumi.Input['ClusterRkeConfigNetworkCalicoNetworkProviderArgs'] calico_network_provider: Calico provider config for RKE network (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigNetworkCanalNetworkProviderArgs'] canal_network_provider: Canal provider config for RKE network (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigNetworkFlannelNetworkProviderArgs'] flannel_network_provider: Flannel provider config for RKE network (list maxitems:1)
        :param pulumi.Input[float] mtu: Network provider MTU. Default `0` (int)
        :param pulumi.Input[Mapping[str, Any]] options: RKE options for network (map)
        :param pulumi.Input[str] plugin: Plugin for RKE network. `canal` (default), `flannel`, `calico`, `none` and `weave` are supported. (string)
        :param pulumi.Input['ClusterRkeConfigNetworkWeaveNetworkProviderArgs'] weave_network_provider: Weave provider config for RKE network (list maxitems:1)
        """
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkCalicoNetworkProviderArgs']]:
        """
        Calico provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "calico_network_provider")

    @calico_network_provider.setter
    def calico_network_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigNetworkCalicoNetworkProviderArgs']]):
        pulumi.set(self, "calico_network_provider", value)

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkCanalNetworkProviderArgs']]:
        """
        Canal provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "canal_network_provider")

    @canal_network_provider.setter
    def canal_network_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigNetworkCanalNetworkProviderArgs']]):
        pulumi.set(self, "canal_network_provider", value)

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkFlannelNetworkProviderArgs']]:
        """
        Flannel provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "flannel_network_provider")

    @flannel_network_provider.setter
    def flannel_network_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigNetworkFlannelNetworkProviderArgs']]):
        pulumi.set(self, "flannel_network_provider", value)

    @property
    @pulumi.getter
    def mtu(self) -> Optional[pulumi.Input[float]]:
        """
        Network provider MTU. Default `0` (int)
        """
        return pulumi.get(self, "mtu")

    @mtu.setter
    def mtu(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "mtu", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        RKE options for network (map)
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter
    def plugin(self) -> Optional[pulumi.Input[str]]:
        """
        Plugin for RKE network. `canal` (default), `flannel`, `calico`, `none` and `weave` are supported. (string)
        """
        return pulumi.get(self, "plugin")

    @plugin.setter
    def plugin(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "plugin", value)

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkWeaveNetworkProviderArgs']]:
        """
        Weave provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "weave_network_provider")

    @weave_network_provider.setter
    def weave_network_provider(self, value: Optional[pulumi.Input['ClusterRkeConfigNetworkWeaveNetworkProviderArgs']]):
        pulumi.set(self, "weave_network_provider", value)


@pulumi.input_type
class ClusterRkeConfigNetworkCalicoNetworkProviderArgs:
    def __init__(__self__, *,
                 cloud_provider: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cloud_provider: RKE options for Calico network provider (string)
        """
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> Optional[pulumi.Input[str]]:
        """
        RKE options for Calico network provider (string)
        """
        return pulumi.get(self, "cloud_provider")

    @cloud_provider.setter
    def cloud_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_provider", value)


@pulumi.input_type
class ClusterRkeConfigNetworkCanalNetworkProviderArgs:
    def __init__(__self__, *,
                 iface: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] iface: Iface config Flannel network provider (string)
        """
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[pulumi.Input[str]]:
        """
        Iface config Flannel network provider (string)
        """
        return pulumi.get(self, "iface")

    @iface.setter
    def iface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iface", value)


@pulumi.input_type
class ClusterRkeConfigNetworkFlannelNetworkProviderArgs:
    def __init__(__self__, *,
                 iface: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] iface: Iface config Flannel network provider (string)
        """
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[pulumi.Input[str]]:
        """
        Iface config Flannel network provider (string)
        """
        return pulumi.get(self, "iface")

    @iface.setter
    def iface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iface", value)


@pulumi.input_type
class ClusterRkeConfigNetworkWeaveNetworkProviderArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: Registry password (string)
        """
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        Registry password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)


@pulumi.input_type
class ClusterRkeConfigNodeArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 roles: pulumi.Input[List[pulumi.Input[str]]],
                 user: pulumi.Input[str],
                 docker_socket: Optional[pulumi.Input[str]] = None,
                 hostname_override: Optional[pulumi.Input[str]] = None,
                 internal_address: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 node_id: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[str]] = None,
                 ssh_agent_auth: Optional[pulumi.Input[bool]] = None,
                 ssh_key: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] address: Address ip for node (string)
        :param pulumi.Input[List[pulumi.Input[str]]] roles: Roles for the node. `controlplane`, `etcd` and `worker` are supported. (list)
        :param pulumi.Input[str] user: Registry user (string)
        :param pulumi.Input[str] docker_socket: Docker socket for node (string)
        :param pulumi.Input[str] hostname_override: Hostname override for node (string)
        :param pulumi.Input[str] internal_address: Internal ip for node (string)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for cluster registration token object (map)
        :param pulumi.Input[str] node_id: Id for the node (string)
        :param pulumi.Input[str] port: Port for node. Default `22` (string)
        :param pulumi.Input[bool] ssh_agent_auth: Use ssh agent auth. Default `false` (bool)
        :param pulumi.Input[str] ssh_key: Node SSH private key (string)
        :param pulumi.Input[str] ssh_key_path: Node SSH private key path (string)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        """
        Address ip for node (string)
        """
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter
    def roles(self) -> pulumi.Input[List[pulumi.Input[str]]]:
        """
        Roles for the node. `controlplane`, `etcd` and `worker` are supported. (list)
        """
        return pulumi.get(self, "roles")

    @roles.setter
    def roles(self, value: pulumi.Input[List[pulumi.Input[str]]]):
        pulumi.set(self, "roles", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        """
        Registry user (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> Optional[pulumi.Input[str]]:
        """
        Docker socket for node (string)
        """
        return pulumi.get(self, "docker_socket")

    @docker_socket.setter
    def docker_socket(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_socket", value)

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[pulumi.Input[str]]:
        """
        Hostname override for node (string)
        """
        return pulumi.get(self, "hostname_override")

    @hostname_override.setter
    def hostname_override(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hostname_override", value)

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[pulumi.Input[str]]:
        """
        Internal ip for node (string)
        """
        return pulumi.get(self, "internal_address")

    @internal_address.setter
    def internal_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "internal_address", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for cluster registration token object (map)
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[str]]:
        """
        Id for the node (string)
        """
        return pulumi.get(self, "node_id")

    @node_id.setter
    def node_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_id", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        """
        Port for node. Default `22` (string)
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[pulumi.Input[bool]]:
        """
        Use ssh agent auth. Default `false` (bool)
        """
        return pulumi.get(self, "ssh_agent_auth")

    @ssh_agent_auth.setter
    def ssh_agent_auth(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssh_agent_auth", value)

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[pulumi.Input[str]]:
        """
        Node SSH private key (string)
        """
        return pulumi.get(self, "ssh_key")

    @ssh_key.setter
    def ssh_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        """
        Node SSH private key path (string)
        """
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)


@pulumi.input_type
class ClusterRkeConfigPrivateRegistryArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 is_default: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] url: Registry URL (string)
        :param pulumi.Input[bool] is_default: Set as default registry. Default `false` (bool)
        :param pulumi.Input[str] password: Registry password (string)
        :param pulumi.Input[str] user: Registry user (string)
        """
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Registry URL (string)
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[pulumi.Input[bool]]:
        """
        Set as default registry. Default `false` (bool)
        """
        return pulumi.get(self, "is_default")

    @is_default.setter
    def is_default(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_default", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        Registry password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[str]]:
        """
        Registry user (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class ClusterRkeConfigServicesArgs:
    def __init__(__self__, *,
                 etcd: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdArgs']] = None,
                 kube_api: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiArgs']] = None,
                 kube_controller: Optional[pulumi.Input['ClusterRkeConfigServicesKubeControllerArgs']] = None,
                 kubelet: Optional[pulumi.Input['ClusterRkeConfigServicesKubeletArgs']] = None,
                 kubeproxy: Optional[pulumi.Input['ClusterRkeConfigServicesKubeproxyArgs']] = None,
                 scheduler: Optional[pulumi.Input['ClusterRkeConfigServicesSchedulerArgs']] = None):
        """
        :param pulumi.Input['ClusterRkeConfigServicesEtcdArgs'] etcd: Etcd options for RKE services (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigServicesKubeApiArgs'] kube_api: Kube API options for RKE services (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigServicesKubeControllerArgs'] kube_controller: Kube Controller options for RKE services (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigServicesKubeletArgs'] kubelet: Kubelet options for RKE services (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigServicesKubeproxyArgs'] kubeproxy: Kubeproxy options for RKE services (list maxitems:1)
        :param pulumi.Input['ClusterRkeConfigServicesSchedulerArgs'] scheduler: Scheduler options for RKE services (list maxitems:1)
        """
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if kube_api is not None:
            pulumi.set(__self__, "kube_api", kube_api)
        if kube_controller is not None:
            pulumi.set(__self__, "kube_controller", kube_controller)
        if kubelet is not None:
            pulumi.set(__self__, "kubelet", kubelet)
        if kubeproxy is not None:
            pulumi.set(__self__, "kubeproxy", kubeproxy)
        if scheduler is not None:
            pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesEtcdArgs']]:
        """
        Etcd options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "etcd")

    @etcd.setter
    def etcd(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdArgs']]):
        pulumi.set(self, "etcd", value)

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiArgs']]:
        """
        Kube API options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kube_api")

    @kube_api.setter
    def kube_api(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiArgs']]):
        pulumi.set(self, "kube_api", value)

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeControllerArgs']]:
        """
        Kube Controller options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kube_controller")

    @kube_controller.setter
    def kube_controller(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeControllerArgs']]):
        pulumi.set(self, "kube_controller", value)

    @property
    @pulumi.getter
    def kubelet(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeletArgs']]:
        """
        Kubelet options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kubelet")

    @kubelet.setter
    def kubelet(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeletArgs']]):
        pulumi.set(self, "kubelet", value)

    @property
    @pulumi.getter
    def kubeproxy(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeproxyArgs']]:
        """
        Kubeproxy options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kubeproxy")

    @kubeproxy.setter
    def kubeproxy(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeproxyArgs']]):
        pulumi.set(self, "kubeproxy", value)

    @property
    @pulumi.getter
    def scheduler(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesSchedulerArgs']]:
        """
        Scheduler options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "scheduler")

    @scheduler.setter
    def scheduler(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesSchedulerArgs']]):
        pulumi.set(self, "scheduler", value)


@pulumi.input_type
class ClusterRkeConfigServicesEtcdArgs:
    def __init__(__self__, *,
                 backup_config: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigArgs']] = None,
                 ca_cert: Optional[pulumi.Input[str]] = None,
                 cert: Optional[pulumi.Input[str]] = None,
                 creation: Optional[pulumi.Input[str]] = None,
                 external_urls: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 gid: Optional[pulumi.Input[float]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 retention: Optional[pulumi.Input[str]] = None,
                 snapshot: Optional[pulumi.Input[bool]] = None,
                 uid: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigArgs'] backup_config: Backup options for etcd service. Just for Rancher v2.2.x (list maxitems:1)
        :param pulumi.Input[str] ca_cert: TLS CA certificate for etcd service (string)
        :param pulumi.Input[str] cert: TLS certificate for etcd service (string)
        :param pulumi.Input[str] creation: Creation option for etcd service (string)
        :param pulumi.Input[List[pulumi.Input[str]]] external_urls: External urls for etcd service (list)
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_binds: Extra binds for scheduler service (list)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_envs: Extra environment for scheduler service (list)
        :param pulumi.Input[float] gid: Etcd service GID. Default: `0`. For Rancher v2.3.x or above (int)
        :param pulumi.Input[str] image: Docker image for scheduler service (string)
        :param pulumi.Input[str] key: TLS key for etcd service (string)
        :param pulumi.Input[str] path: (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        :param pulumi.Input[str] retention: Retention for etcd backup. Default `6` (int)
        :param pulumi.Input[bool] snapshot: Snapshot option for etcd service (bool)
        :param pulumi.Input[float] uid: Etcd service UID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigArgs']]:
        """
        Backup options for etcd service. Just for Rancher v2.2.x (list maxitems:1)
        """
        return pulumi.get(self, "backup_config")

    @backup_config.setter
    def backup_config(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigArgs']]):
        pulumi.set(self, "backup_config", value)

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> Optional[pulumi.Input[str]]:
        """
        TLS CA certificate for etcd service (string)
        """
        return pulumi.get(self, "ca_cert")

    @ca_cert.setter
    def ca_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_cert", value)

    @property
    @pulumi.getter
    def cert(self) -> Optional[pulumi.Input[str]]:
        """
        TLS certificate for etcd service (string)
        """
        return pulumi.get(self, "cert")

    @cert.setter
    def cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cert", value)

    @property
    @pulumi.getter
    def creation(self) -> Optional[pulumi.Input[str]]:
        """
        Creation option for etcd service (string)
        """
        return pulumi.get(self, "creation")

    @creation.setter
    def creation(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "creation", value)

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        External urls for etcd service (list)
        """
        return pulumi.get(self, "external_urls")

    @external_urls.setter
    def external_urls(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "external_urls", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def gid(self) -> Optional[pulumi.Input[float]]:
        """
        Etcd service GID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        return pulumi.get(self, "gid")

    @gid.setter
    def gid(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "gid", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        TLS key for etcd service (string)
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[str]]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "retention", value)

    @property
    @pulumi.getter
    def snapshot(self) -> Optional[pulumi.Input[bool]]:
        """
        Snapshot option for etcd service (bool)
        """
        return pulumi.get(self, "snapshot")

    @snapshot.setter
    def snapshot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "snapshot", value)

    @property
    @pulumi.getter
    def uid(self) -> Optional[pulumi.Input[float]]:
        """
        Etcd service UID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        return pulumi.get(self, "uid")

    @uid.setter
    def uid(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "uid", value)


@pulumi.input_type
class ClusterRkeConfigServicesEtcdBackupConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 interval_hours: Optional[pulumi.Input[float]] = None,
                 retention: Optional[pulumi.Input[float]] = None,
                 s3_backup_config: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']] = None,
                 safe_timestamp: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable scheduled cluster scan. Default: `false` (bool)
        :param pulumi.Input[float] interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param pulumi.Input[float] retention: Retention for etcd backup. Default `6` (int)
        :param pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs'] s3_backup_config: S3 config options for etcd backup (list maxitems:1)
        :param pulumi.Input[bool] safe_timestamp: Safe timestamp for etcd backup. Default: `false` (bool)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable scheduled cluster scan. Default: `false` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[pulumi.Input[float]]:
        """
        Interval hours for etcd backup. Default `12` (int)
        """
        return pulumi.get(self, "interval_hours")

    @interval_hours.setter
    def interval_hours(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "interval_hours", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[float]]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "retention", value)

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']]:
        """
        S3 config options for etcd backup (list maxitems:1)
        """
        return pulumi.get(self, "s3_backup_config")

    @s3_backup_config.setter
    def s3_backup_config(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']]):
        pulumi.set(self, "s3_backup_config", value)

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[pulumi.Input[bool]]:
        """
        Safe timestamp for etcd backup. Default: `false` (bool)
        """
        return pulumi.get(self, "safe_timestamp")

    @safe_timestamp.setter
    def safe_timestamp(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "safe_timestamp", value)


@pulumi.input_type
class ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 endpoint: pulumi.Input[str],
                 access_key: Optional[pulumi.Input[str]] = None,
                 custom_ca: Optional[pulumi.Input[str]] = None,
                 folder: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 secret_key: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] bucket_name: Bucket name for S3 service (string)
        :param pulumi.Input[str] endpoint: Endpoint for S3 service (string)
        :param pulumi.Input[str] access_key: The AWS Client ID to use (string)
        :param pulumi.Input[str] custom_ca: Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        :param pulumi.Input[str] folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param pulumi.Input[str] region: GKE cluster region. Conflicts with `zone` (string)
        :param pulumi.Input[str] secret_key: The AWS Client Secret associated with the Client ID (string)
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        """
        Bucket name for S3 service (string)
        """
        return pulumi.get(self, "bucket_name")

    @bucket_name.setter
    def bucket_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_name", value)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint for S3 service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS Client ID to use (string)
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[pulumi.Input[str]]:
        """
        Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        """
        return pulumi.get(self, "custom_ca")

    @custom_ca.setter
    def custom_ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_ca", value)

    @property
    @pulumi.getter
    def folder(self) -> Optional[pulumi.Input[str]]:
        """
        Folder for S3 service. Available from Rancher v2.2.7 (string)
        """
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        GKE cluster region. Conflicts with `zone` (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS Client Secret associated with the Client ID (string)
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret_key", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiArgs:
    def __init__(__self__, *,
                 admission_configuration: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 always_pull_images: Optional[pulumi.Input[bool]] = None,
                 audit_log: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogArgs']] = None,
                 event_rate_limit: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiEventRateLimitArgs']] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 pod_security_policy: Optional[pulumi.Input[bool]] = None,
                 secrets_encryption_config: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']] = None,
                 service_cluster_ip_range: Optional[pulumi.Input[str]] = None,
                 service_node_port_range: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] admission_configuration: Admission configuration (map)
        :param pulumi.Input[bool] always_pull_images: Enable [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages) Admission controller plugin. [Rancher docs](https://rancher.com/docs/rke/latest/en/config-options/services/#kubernetes-api-server-options) Default: `false` (bool)
        :param pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogArgs'] audit_log: K8s audit log configuration. (list maxitems: 1)
        :param pulumi.Input['ClusterRkeConfigServicesKubeApiEventRateLimitArgs'] event_rate_limit: K8s event rate limit configuration. (list maxitems: 1)
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_binds: Extra binds for scheduler service (list)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_envs: Extra environment for scheduler service (list)
        :param pulumi.Input[str] image: Docker image for scheduler service (string)
        :param pulumi.Input[bool] pod_security_policy: Pod Security Policy option for kube API service. Default `false` (bool)
        :param pulumi.Input['ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs'] secrets_encryption_config: [Encrypt k8s secret data configration](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/). (list maxitem: 1)
        :param pulumi.Input[str] service_cluster_ip_range: Service Cluster ip Range option for kube controller service (string)
        :param pulumi.Input[str] service_node_port_range: Service Node Port Range option for kube API service (string)
        """
        if admission_configuration is not None:
            pulumi.set(__self__, "admission_configuration", admission_configuration)
        if always_pull_images is not None:
            pulumi.set(__self__, "always_pull_images", always_pull_images)
        if audit_log is not None:
            pulumi.set(__self__, "audit_log", audit_log)
        if event_rate_limit is not None:
            pulumi.set(__self__, "event_rate_limit", event_rate_limit)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if service_node_port_range is not None:
            pulumi.set(__self__, "service_node_port_range", service_node_port_range)

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Admission configuration (map)
        """
        return pulumi.get(self, "admission_configuration")

    @admission_configuration.setter
    def admission_configuration(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "admission_configuration", value)

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages) Admission controller plugin. [Rancher docs](https://rancher.com/docs/rke/latest/en/config-options/services/#kubernetes-api-server-options) Default: `false` (bool)
        """
        return pulumi.get(self, "always_pull_images")

    @always_pull_images.setter
    def always_pull_images(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "always_pull_images", value)

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogArgs']]:
        """
        K8s audit log configuration. (list maxitems: 1)
        """
        return pulumi.get(self, "audit_log")

    @audit_log.setter
    def audit_log(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogArgs']]):
        pulumi.set(self, "audit_log", value)

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiEventRateLimitArgs']]:
        """
        K8s event rate limit configuration. (list maxitems: 1)
        """
        return pulumi.get(self, "event_rate_limit")

    @event_rate_limit.setter
    def event_rate_limit(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiEventRateLimitArgs']]):
        pulumi.set(self, "event_rate_limit", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[pulumi.Input[bool]]:
        """
        Pod Security Policy option for kube API service. Default `false` (bool)
        """
        return pulumi.get(self, "pod_security_policy")

    @pod_security_policy.setter
    def pod_security_policy(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pod_security_policy", value)

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']]:
        """
        [Encrypt k8s secret data configration](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/). (list maxitem: 1)
        """
        return pulumi.get(self, "secrets_encryption_config")

    @secrets_encryption_config.setter
    def secrets_encryption_config(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']]):
        pulumi.set(self, "secrets_encryption_config", value)

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[pulumi.Input[str]]:
        """
        Service Cluster ip Range option for kube controller service (string)
        """
        return pulumi.get(self, "service_cluster_ip_range")

    @service_cluster_ip_range.setter
    def service_cluster_ip_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_cluster_ip_range", value)

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> Optional[pulumi.Input[str]]:
        """
        Service Node Port Range option for kube API service (string)
        """
        return pulumi.get(self, "service_node_port_range")

    @service_node_port_range.setter
    def service_node_port_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_node_port_range", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiAuditLogArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs']] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs'] configuration: Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        :param pulumi.Input[bool] enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs']]:
        """
        Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        """
        return pulumi.get(self, "configuration")

    @configuration.setter
    def configuration(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs']]):
        pulumi.set(self, "configuration", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable scheduled cluster scan. Default: `false` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs:
    def __init__(__self__, *,
                 format: Optional[pulumi.Input[str]] = None,
                 max_age: Optional[pulumi.Input[float]] = None,
                 max_backup: Optional[pulumi.Input[float]] = None,
                 max_size: Optional[pulumi.Input[float]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 policy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] format: Audit log format. Default: 'json' (string)
        :param pulumi.Input[float] max_age: Audit log max age. Default: `30` (int)
        :param pulumi.Input[float] max_backup: Audit log max backup. Default: `10` (int)
        :param pulumi.Input[float] max_size: Audit log max size. Default: `100` (int)
        :param pulumi.Input[str] path: (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        :param pulumi.Input[str] policy: Audit policy yaml encoded definition. `apiVersion` and `kind: Policy\nrules:"` fields are required in the yaml. Ex. `"apiVersion: audit.k8s.io/v1\nkind: Policy\nrules:\n- level: RequestResponse\n  resources:\n  - resources:\n    - pods\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string)
        """
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def format(self) -> Optional[pulumi.Input[str]]:
        """
        Audit log format. Default: 'json' (string)
        """
        return pulumi.get(self, "format")

    @format.setter
    def format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "format", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[float]]:
        """
        Audit log max age. Default: `30` (int)
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_age", value)

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[pulumi.Input[float]]:
        """
        Audit log max backup. Default: `10` (int)
        """
        return pulumi.get(self, "max_backup")

    @max_backup.setter
    def max_backup(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_backup", value)

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[float]]:
        """
        Audit log max size. Default: `100` (int)
        """
        return pulumi.get(self, "max_size")

    @max_size.setter
    def max_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_size", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def policy(self) -> Optional[pulumi.Input[str]]:
        """
        Audit policy yaml encoded definition. `apiVersion` and `kind: Policy\nrules:"` fields are required in the yaml. Ex. `"apiVersion: audit.k8s.io/v1\nkind: Policy\nrules:\n- level: RequestResponse\n  resources:\n  - resources:\n    - pods\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string)
        """
        return pulumi.get(self, "policy")

    @policy.setter
    def policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "policy", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiEventRateLimitArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] configuration: Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        :param pulumi.Input[bool] enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[pulumi.Input[str]]:
        """
        Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        """
        return pulumi.get(self, "configuration")

    @configuration.setter
    def configuration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "configuration", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable scheduled cluster scan. Default: `false` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs:
    def __init__(__self__, *,
                 custom_config: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] custom_config: Secrets encryption yaml encoded custom configuration. `"apiVersion"` and `"kind":"EncryptionConfiguration"` fields are required in the yaml. Ex. `apiVersion: apiserver.config.k8s.io/v1\nkind: EncryptionConfiguration\nresources:\n- resources:\n  - secrets\n  providers:\n  - aescbc:\n      keys:\n      - name: k-fw5hn\n        secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=\n    identity: {}\n` [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string)
        :param pulumi.Input[bool] enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        if custom_config is not None:
            pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="customConfig")
    def custom_config(self) -> Optional[pulumi.Input[str]]:
        """
        Secrets encryption yaml encoded custom configuration. `"apiVersion"` and `"kind":"EncryptionConfiguration"` fields are required in the yaml. Ex. `apiVersion: apiserver.config.k8s.io/v1\nkind: EncryptionConfiguration\nresources:\n- resources:\n  - secrets\n  providers:\n  - aescbc:\n      keys:\n      - name: k-fw5hn\n        secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=\n    identity: {}\n` [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string)
        """
        return pulumi.get(self, "custom_config")

    @custom_config.setter
    def custom_config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_config", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable scheduled cluster scan. Default: `false` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeControllerArgs:
    def __init__(__self__, *,
                 cluster_cidr: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 service_cluster_ip_range: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cluster_cidr: Cluster CIDR option for kube controller service (string)
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_binds: Extra binds for scheduler service (list)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_envs: Extra environment for scheduler service (list)
        :param pulumi.Input[str] image: Docker image for scheduler service (string)
        :param pulumi.Input[str] service_cluster_ip_range: Service Cluster ip Range option for kube controller service (string)
        """
        if cluster_cidr is not None:
            pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster CIDR option for kube controller service (string)
        """
        return pulumi.get(self, "cluster_cidr")

    @cluster_cidr.setter
    def cluster_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_cidr", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[pulumi.Input[str]]:
        """
        Service Cluster ip Range option for kube controller service (string)
        """
        return pulumi.get(self, "service_cluster_ip_range")

    @service_cluster_ip_range.setter
    def service_cluster_ip_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_cluster_ip_range", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeletArgs:
    def __init__(__self__, *,
                 cluster_dns_server: Optional[pulumi.Input[str]] = None,
                 cluster_domain: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 fail_swap_on: Optional[pulumi.Input[bool]] = None,
                 generate_serving_certificate: Optional[pulumi.Input[bool]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 infra_container_image: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cluster_dns_server: Cluster DNS Server option for kubelet service (string)
        :param pulumi.Input[str] cluster_domain: Cluster Domain option for kubelet service (string)
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_binds: Extra binds for scheduler service (list)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_envs: Extra environment for scheduler service (list)
        :param pulumi.Input[bool] fail_swap_on: Enable or disable failing when swap on is not supported (bool)
        :param pulumi.Input[bool] generate_serving_certificate: [Generate a certificate signed by the kube-ca](https://rancher.com/docs/rke/latest/en/config-options/services/#kubelet-serving-certificate-requirements). Default `false` (bool)
        :param pulumi.Input[str] image: Docker image for scheduler service (string)
        :param pulumi.Input[str] infra_container_image: Infra container image for kubelet service (string)
        """
        if cluster_dns_server is not None:
            pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        if cluster_domain is not None:
            pulumi.set(__self__, "cluster_domain", cluster_domain)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if fail_swap_on is not None:
            pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if infra_container_image is not None:
            pulumi.set(__self__, "infra_container_image", infra_container_image)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster DNS Server option for kubelet service (string)
        """
        return pulumi.get(self, "cluster_dns_server")

    @cluster_dns_server.setter
    def cluster_dns_server(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_dns_server", value)

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster Domain option for kubelet service (string)
        """
        return pulumi.get(self, "cluster_domain")

    @cluster_domain.setter
    def cluster_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_domain", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable or disable failing when swap on is not supported (bool)
        """
        return pulumi.get(self, "fail_swap_on")

    @fail_swap_on.setter
    def fail_swap_on(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "fail_swap_on", value)

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        [Generate a certificate signed by the kube-ca](https://rancher.com/docs/rke/latest/en/config-options/services/#kubelet-serving-certificate-requirements). Default `false` (bool)
        """
        return pulumi.get(self, "generate_serving_certificate")

    @generate_serving_certificate.setter
    def generate_serving_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "generate_serving_certificate", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> Optional[pulumi.Input[str]]:
        """
        Infra container image for kubelet service (string)
        """
        return pulumi.get(self, "infra_container_image")

    @infra_container_image.setter
    def infra_container_image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "infra_container_image", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeproxyArgs:
    def __init__(__self__, *,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_binds: Extra binds for scheduler service (list)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_envs: Extra environment for scheduler service (list)
        :param pulumi.Input[str] image: Docker image for scheduler service (string)
        """
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)


@pulumi.input_type
class ClusterRkeConfigServicesSchedulerArgs:
    def __init__(__self__, *,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] extra_args: Extra arguments for scheduler service (map)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_binds: Extra binds for scheduler service (list)
        :param pulumi.Input[List[pulumi.Input[str]]] extra_envs: Extra environment for scheduler service (list)
        :param pulumi.Input[str] image: Docker image for scheduler service (string)
        """
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)


@pulumi.input_type
class ClusterRkeConfigUpgradeStrategyArgs:
    def __init__(__self__, *,
                 drain: Optional[pulumi.Input[bool]] = None,
                 drain_input: Optional[pulumi.Input['ClusterRkeConfigUpgradeStrategyDrainInputArgs']] = None,
                 max_unavailable_controlplane: Optional[pulumi.Input[str]] = None,
                 max_unavailable_worker: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] drain: RKE drain nodes. Default: `false` (bool)
        :param pulumi.Input['ClusterRkeConfigUpgradeStrategyDrainInputArgs'] drain_input: RKE drain node input (list Maxitems: 1)
        :param pulumi.Input[str] max_unavailable_controlplane: RKE max unavailable controlplane nodes. Default: `1` (string)
        :param pulumi.Input[str] max_unavailable_worker: RKE max unavailable worker nodes. Default: `10%` (string)
        """
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if drain_input is not None:
            pulumi.set(__self__, "drain_input", drain_input)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

    @property
    @pulumi.getter
    def drain(self) -> Optional[pulumi.Input[bool]]:
        """
        RKE drain nodes. Default: `false` (bool)
        """
        return pulumi.get(self, "drain")

    @drain.setter
    def drain(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drain", value)

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> Optional[pulumi.Input['ClusterRkeConfigUpgradeStrategyDrainInputArgs']]:
        """
        RKE drain node input (list Maxitems: 1)
        """
        return pulumi.get(self, "drain_input")

    @drain_input.setter
    def drain_input(self, value: Optional[pulumi.Input['ClusterRkeConfigUpgradeStrategyDrainInputArgs']]):
        pulumi.set(self, "drain_input", value)

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[pulumi.Input[str]]:
        """
        RKE max unavailable controlplane nodes. Default: `1` (string)
        """
        return pulumi.get(self, "max_unavailable_controlplane")

    @max_unavailable_controlplane.setter
    def max_unavailable_controlplane(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_unavailable_controlplane", value)

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[pulumi.Input[str]]:
        """
        RKE max unavailable worker nodes. Default: `10%` (string)
        """
        return pulumi.get(self, "max_unavailable_worker")

    @max_unavailable_worker.setter
    def max_unavailable_worker(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_unavailable_worker", value)


@pulumi.input_type
class ClusterRkeConfigUpgradeStrategyDrainInputArgs:
    def __init__(__self__, *,
                 delete_local_data: Optional[pulumi.Input[bool]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 grace_period: Optional[pulumi.Input[float]] = None,
                 ignore_daemon_sets: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[bool] delete_local_data: Delete RKE node local data. Default: `false` (bool)
        :param pulumi.Input[bool] force: Force RKE node drain. Default: `false` (bool)
        :param pulumi.Input[float] grace_period: RKE node drain grace period. Default: `-1` (int)
        :param pulumi.Input[bool] ignore_daemon_sets: Ignore RKE daemon sets. Default: `true` (bool)
        :param pulumi.Input[float] timeout: RKE node drain timeout. Default: `60` (int)
        """
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[pulumi.Input[bool]]:
        """
        Delete RKE node local data. Default: `false` (bool)
        """
        return pulumi.get(self, "delete_local_data")

    @delete_local_data.setter
    def delete_local_data(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "delete_local_data", value)

    @property
    @pulumi.getter
    def force(self) -> Optional[pulumi.Input[bool]]:
        """
        Force RKE node drain. Default: `false` (bool)
        """
        return pulumi.get(self, "force")

    @force.setter
    def force(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force", value)

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[pulumi.Input[float]]:
        """
        RKE node drain grace period. Default: `-1` (int)
        """
        return pulumi.get(self, "grace_period")

    @grace_period.setter
    def grace_period(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "grace_period", value)

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[pulumi.Input[bool]]:
        """
        Ignore RKE daemon sets. Default: `true` (bool)
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @ignore_daemon_sets.setter
    def ignore_daemon_sets(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_daemon_sets", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[float]]:
        """
        RKE node drain timeout. Default: `60` (int)
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class ClusterScheduledClusterScanArgs:
    def __init__(__self__, *,
                 scan_config: pulumi.Input['ClusterScheduledClusterScanScanConfigArgs'],
                 schedule_config: pulumi.Input['ClusterScheduledClusterScanScheduleConfigArgs'],
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['ClusterScheduledClusterScanScanConfigArgs'] scan_config: Cluster scan config (List maxitems:1)
        :param pulumi.Input['ClusterScheduledClusterScanScheduleConfigArgs'] schedule_config: Cluster scan schedule config (list maxitems:1)
        :param pulumi.Input[bool] enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        pulumi.set(__self__, "scan_config", scan_config)
        pulumi.set(__self__, "schedule_config", schedule_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="scanConfig")
    def scan_config(self) -> pulumi.Input['ClusterScheduledClusterScanScanConfigArgs']:
        """
        Cluster scan config (List maxitems:1)
        """
        return pulumi.get(self, "scan_config")

    @scan_config.setter
    def scan_config(self, value: pulumi.Input['ClusterScheduledClusterScanScanConfigArgs']):
        pulumi.set(self, "scan_config", value)

    @property
    @pulumi.getter(name="scheduleConfig")
    def schedule_config(self) -> pulumi.Input['ClusterScheduledClusterScanScheduleConfigArgs']:
        """
        Cluster scan schedule config (list maxitems:1)
        """
        return pulumi.get(self, "schedule_config")

    @schedule_config.setter
    def schedule_config(self, value: pulumi.Input['ClusterScheduledClusterScanScheduleConfigArgs']):
        pulumi.set(self, "schedule_config", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable scheduled cluster scan. Default: `false` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterScheduledClusterScanScanConfigArgs:
    def __init__(__self__, *,
                 cis_scan_config: Optional[pulumi.Input['ClusterScheduledClusterScanScanConfigCisScanConfigArgs']] = None):
        """
        :param pulumi.Input['ClusterScheduledClusterScanScanConfigCisScanConfigArgs'] cis_scan_config: Cluster Cis Scan config (List maxitems:1)
        """
        if cis_scan_config is not None:
            pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> Optional[pulumi.Input['ClusterScheduledClusterScanScanConfigCisScanConfigArgs']]:
        """
        Cluster Cis Scan config (List maxitems:1)
        """
        return pulumi.get(self, "cis_scan_config")

    @cis_scan_config.setter
    def cis_scan_config(self, value: Optional[pulumi.Input['ClusterScheduledClusterScanScanConfigCisScanConfigArgs']]):
        pulumi.set(self, "cis_scan_config", value)


@pulumi.input_type
class ClusterScheduledClusterScanScanConfigCisScanConfigArgs:
    def __init__(__self__, *,
                 debug_master: Optional[pulumi.Input[bool]] = None,
                 debug_worker: Optional[pulumi.Input[bool]] = None,
                 override_benchmark_version: Optional[pulumi.Input[str]] = None,
                 override_skips: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 profile: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] debug_master: Debug master. Default: `false` (bool)
        :param pulumi.Input[bool] debug_worker: Debug worker. Default: `false` (bool)
        :param pulumi.Input[str] override_benchmark_version: Override benchmark version (string)
        :param pulumi.Input[List[pulumi.Input[str]]] override_skips: Override skip (string)
        :param pulumi.Input[str] profile: Cis scan profile. Allowed values: `"permissive" (default) || "hardened"` (string)
        """
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="debugMaster")
    def debug_master(self) -> Optional[pulumi.Input[bool]]:
        """
        Debug master. Default: `false` (bool)
        """
        return pulumi.get(self, "debug_master")

    @debug_master.setter
    def debug_master(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "debug_master", value)

    @property
    @pulumi.getter(name="debugWorker")
    def debug_worker(self) -> Optional[pulumi.Input[bool]]:
        """
        Debug worker. Default: `false` (bool)
        """
        return pulumi.get(self, "debug_worker")

    @debug_worker.setter
    def debug_worker(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "debug_worker", value)

    @property
    @pulumi.getter(name="overrideBenchmarkVersion")
    def override_benchmark_version(self) -> Optional[pulumi.Input[str]]:
        """
        Override benchmark version (string)
        """
        return pulumi.get(self, "override_benchmark_version")

    @override_benchmark_version.setter
    def override_benchmark_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "override_benchmark_version", value)

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Override skip (string)
        """
        return pulumi.get(self, "override_skips")

    @override_skips.setter
    def override_skips(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "override_skips", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        """
        Cis scan profile. Allowed values: `"permissive" (default) || "hardened"` (string)
        """
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "profile", value)


@pulumi.input_type
class ClusterScheduledClusterScanScheduleConfigArgs:
    def __init__(__self__, *,
                 cron_schedule: pulumi.Input[str],
                 retention: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] cron_schedule: Crontab schedule. It should contains 5 fields `"<min> <hour> <month_day> <month> <week_day>"` (string)
        :param pulumi.Input[float] retention: Retention for etcd backup. Default `6` (int)
        """
        pulumi.set(__self__, "cron_schedule", cron_schedule)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)

    @property
    @pulumi.getter(name="cronSchedule")
    def cron_schedule(self) -> pulumi.Input[str]:
        """
        Crontab schedule. It should contains 5 fields `"<min> <hour> <month_day> <month> <week_day>"` (string)
        """
        return pulumi.get(self, "cron_schedule")

    @cron_schedule.setter
    def cron_schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "cron_schedule", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[float]]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "retention", value)


@pulumi.input_type
class ClusterTemplateMemberArgs:
    def __init__(__self__, *,
                 access_type: Optional[pulumi.Input[str]] = None,
                 group_principal_id: Optional[pulumi.Input[str]] = None,
                 user_principal_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_type: Member access type. Valid values: `["read-only" | "owner"]` (string)
        :param pulumi.Input[str] group_principal_id: Member group principal id (string)
        :param pulumi.Input[str] user_principal_id: Member user principal id (string)
        """
        if access_type is not None:
            pulumi.set(__self__, "access_type", access_type)
        if group_principal_id is not None:
            pulumi.set(__self__, "group_principal_id", group_principal_id)
        if user_principal_id is not None:
            pulumi.set(__self__, "user_principal_id", user_principal_id)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> Optional[pulumi.Input[str]]:
        """
        Member access type. Valid values: `["read-only" | "owner"]` (string)
        """
        return pulumi.get(self, "access_type")

    @access_type.setter
    def access_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_type", value)

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        Member group principal id (string)
        """
        return pulumi.get(self, "group_principal_id")

    @group_principal_id.setter
    def group_principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_principal_id", value)

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        Member user principal id (string)
        """
        return pulumi.get(self, "user_principal_id")

    @user_principal_id.setter
    def user_principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_principal_id", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionArgs:
    def __init__(__self__, *,
                 cluster_config: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigArgs'],
                 name: pulumi.Input[str],
                 annotations: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 cluster_template_id: Optional[pulumi.Input[str]] = None,
                 default: Optional[pulumi.Input[bool]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 questions: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigArgs'] cluster_config: Cluster configuration (list maxitem: 1)
        :param pulumi.Input[str] name: The cluster template revision name (string)
        :param pulumi.Input[Mapping[str, Any]] annotations: Annotations for the cluster template revision (map)
        :param pulumi.Input[str] cluster_template_id: Cluster template ID (string)
        :param pulumi.Input[bool] default: Default variable value (string)
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        :param pulumi.Input[str] id: The cluster template revision ID (string)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the cluster template revision (map)
        :param pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]] questions: Cluster template questions (list)
        """
        pulumi.set(__self__, "cluster_config", cluster_config)
        pulumi.set(__self__, "name", name)
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_template_id is not None:
            pulumi.set(__self__, "cluster_template_id", cluster_template_id)
        if default is not None:
            pulumi.set(__self__, "default", default)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if questions is not None:
            pulumi.set(__self__, "questions", questions)

    @property
    @pulumi.getter(name="clusterConfig")
    def cluster_config(self) -> pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigArgs']:
        """
        Cluster configuration (list maxitem: 1)
        """
        return pulumi.get(self, "cluster_config")

    @cluster_config.setter
    def cluster_config(self, value: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigArgs']):
        pulumi.set(self, "cluster_config", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The cluster template revision name (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Annotations for the cluster template revision (map)
        """
        return pulumi.get(self, "annotations")

    @annotations.setter
    def annotations(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "annotations", value)

    @property
    @pulumi.getter(name="clusterTemplateId")
    def cluster_template_id(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster template ID (string)
        """
        return pulumi.get(self, "cluster_template_id")

    @cluster_template_id.setter
    def cluster_template_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_template_id", value)

    @property
    @pulumi.getter
    def default(self) -> Optional[pulumi.Input[bool]]:
        """
        Default variable value (string)
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "default", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The cluster template revision ID (string)
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the cluster template revision (map)
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter
    def questions(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]]]:
        """
        Cluster template questions (list)
        """
        return pulumi.get(self, "questions")

    @questions.setter
    def questions(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]]]):
        pulumi.set(self, "questions", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigArgs:
    def __init__(__self__, *,
                 rke_config: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs'],
                 cluster_auth_endpoint: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs']] = None,
                 default_cluster_role_for_project_members: Optional[pulumi.Input[str]] = None,
                 default_pod_security_policy_template_id: Optional[pulumi.Input[str]] = None,
                 desired_agent_image: Optional[pulumi.Input[str]] = None,
                 desired_auth_image: Optional[pulumi.Input[str]] = None,
                 docker_root_dir: Optional[pulumi.Input[str]] = None,
                 enable_cluster_alerting: Optional[pulumi.Input[bool]] = None,
                 enable_cluster_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_network_policy: Optional[pulumi.Input[bool]] = None,
                 scheduled_cluster_scan: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs']] = None,
                 windows_prefered_cluster: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs'] rke_config: Rancher Kubernetes Engine Config (list maxitems: 1)
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs'] cluster_auth_endpoint: Local cluster auth endpoint (list maxitems: 1)
        :param pulumi.Input[str] default_cluster_role_for_project_members: Default cluster role for project members (string)
        :param pulumi.Input[str] default_pod_security_policy_template_id: Default pod security policy template ID (string)
        :param pulumi.Input[str] desired_agent_image: Desired agent image (string)
        :param pulumi.Input[str] desired_auth_image: Desired auth image (string)
        :param pulumi.Input[str] docker_root_dir: Desired auth image (string)
        :param pulumi.Input[bool] enable_cluster_alerting: Enable built-in cluster alerting. Default: `false` (bool)
        :param pulumi.Input[bool] enable_cluster_monitoring: Enable built-in cluster monitoring. Default: `false` (bool)
        :param pulumi.Input[bool] enable_network_policy: Enable project network isolation. Default: `false` (bool)
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs'] scheduled_cluster_scan: Cluster scheduled cis scan. For Rancher v2.4.0 or above (List MaxItem:1)
        :param pulumi.Input[bool] windows_prefered_cluster: Windows prefered cluster. Default: `false` (bool)
        """
        pulumi.set(__self__, "rke_config", rke_config)
        if cluster_auth_endpoint is not None:
            pulumi.set(__self__, "cluster_auth_endpoint", cluster_auth_endpoint)
        if default_cluster_role_for_project_members is not None:
            pulumi.set(__self__, "default_cluster_role_for_project_members", default_cluster_role_for_project_members)
        if default_pod_security_policy_template_id is not None:
            pulumi.set(__self__, "default_pod_security_policy_template_id", default_pod_security_policy_template_id)
        if desired_agent_image is not None:
            pulumi.set(__self__, "desired_agent_image", desired_agent_image)
        if desired_auth_image is not None:
            pulumi.set(__self__, "desired_auth_image", desired_auth_image)
        if docker_root_dir is not None:
            pulumi.set(__self__, "docker_root_dir", docker_root_dir)
        if enable_cluster_alerting is not None:
            pulumi.set(__self__, "enable_cluster_alerting", enable_cluster_alerting)
        if enable_cluster_monitoring is not None:
            pulumi.set(__self__, "enable_cluster_monitoring", enable_cluster_monitoring)
        if enable_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if scheduled_cluster_scan is not None:
            pulumi.set(__self__, "scheduled_cluster_scan", scheduled_cluster_scan)
        if windows_prefered_cluster is not None:
            pulumi.set(__self__, "windows_prefered_cluster", windows_prefered_cluster)

    @property
    @pulumi.getter(name="rkeConfig")
    def rke_config(self) -> pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs']:
        """
        Rancher Kubernetes Engine Config (list maxitems: 1)
        """
        return pulumi.get(self, "rke_config")

    @rke_config.setter
    def rke_config(self, value: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs']):
        pulumi.set(self, "rke_config", value)

    @property
    @pulumi.getter(name="clusterAuthEndpoint")
    def cluster_auth_endpoint(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs']]:
        """
        Local cluster auth endpoint (list maxitems: 1)
        """
        return pulumi.get(self, "cluster_auth_endpoint")

    @cluster_auth_endpoint.setter
    def cluster_auth_endpoint(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs']]):
        pulumi.set(self, "cluster_auth_endpoint", value)

    @property
    @pulumi.getter(name="defaultClusterRoleForProjectMembers")
    def default_cluster_role_for_project_members(self) -> Optional[pulumi.Input[str]]:
        """
        Default cluster role for project members (string)
        """
        return pulumi.get(self, "default_cluster_role_for_project_members")

    @default_cluster_role_for_project_members.setter
    def default_cluster_role_for_project_members(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_cluster_role_for_project_members", value)

    @property
    @pulumi.getter(name="defaultPodSecurityPolicyTemplateId")
    def default_pod_security_policy_template_id(self) -> Optional[pulumi.Input[str]]:
        """
        Default pod security policy template ID (string)
        """
        return pulumi.get(self, "default_pod_security_policy_template_id")

    @default_pod_security_policy_template_id.setter
    def default_pod_security_policy_template_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_pod_security_policy_template_id", value)

    @property
    @pulumi.getter(name="desiredAgentImage")
    def desired_agent_image(self) -> Optional[pulumi.Input[str]]:
        """
        Desired agent image (string)
        """
        return pulumi.get(self, "desired_agent_image")

    @desired_agent_image.setter
    def desired_agent_image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "desired_agent_image", value)

    @property
    @pulumi.getter(name="desiredAuthImage")
    def desired_auth_image(self) -> Optional[pulumi.Input[str]]:
        """
        Desired auth image (string)
        """
        return pulumi.get(self, "desired_auth_image")

    @desired_auth_image.setter
    def desired_auth_image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "desired_auth_image", value)

    @property
    @pulumi.getter(name="dockerRootDir")
    def docker_root_dir(self) -> Optional[pulumi.Input[str]]:
        """
        Desired auth image (string)
        """
        return pulumi.get(self, "docker_root_dir")

    @docker_root_dir.setter
    def docker_root_dir(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_root_dir", value)

    @property
    @pulumi.getter(name="enableClusterAlerting")
    def enable_cluster_alerting(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable built-in cluster alerting. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_cluster_alerting")

    @enable_cluster_alerting.setter
    def enable_cluster_alerting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_cluster_alerting", value)

    @property
    @pulumi.getter(name="enableClusterMonitoring")
    def enable_cluster_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable built-in cluster monitoring. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_cluster_monitoring")

    @enable_cluster_monitoring.setter
    def enable_cluster_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_cluster_monitoring", value)

    @property
    @pulumi.getter(name="enableNetworkPolicy")
    def enable_network_policy(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable project network isolation. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_network_policy")

    @enable_network_policy.setter
    def enable_network_policy(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_network_policy", value)

    @property
    @pulumi.getter(name="scheduledClusterScan")
    def scheduled_cluster_scan(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs']]:
        """
        Cluster scheduled cis scan. For Rancher v2.4.0 or above (List MaxItem:1)
        """
        return pulumi.get(self, "scheduled_cluster_scan")

    @scheduled_cluster_scan.setter
    def scheduled_cluster_scan(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs']]):
        pulumi.set(self, "scheduled_cluster_scan", value)

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[pulumi.Input[bool]]:
        """
        Windows prefered cluster. Default: `false` (bool)
        """
        return pulumi.get(self, "windows_prefered_cluster")

    @windows_prefered_cluster.setter
    def windows_prefered_cluster(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "windows_prefered_cluster", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs:
    def __init__(__self__, *,
                 ca_certs: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 fqdn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        """
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ca_certs")

    @ca_certs.setter
    def ca_certs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_certs", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fqdn")

    @fqdn.setter
    def fqdn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fqdn", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs:
    def __init__(__self__, *,
                 addon_job_timeout: Optional[pulumi.Input[float]] = None,
                 addons: Optional[pulumi.Input[str]] = None,
                 addons_includes: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 authentication: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs']] = None,
                 authorization: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs']] = None,
                 bastion_host: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs']] = None,
                 cloud_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderArgs']] = None,
                 dns: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsArgs']] = None,
                 ignore_docker_version: Optional[pulumi.Input[bool]] = None,
                 ingress: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs']] = None,
                 kubernetes_version: Optional[pulumi.Input[str]] = None,
                 monitoring: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs']] = None,
                 network: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs']] = None,
                 nodes: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs']]]] = None,
                 prefix_path: Optional[pulumi.Input[str]] = None,
                 private_registries: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs']]]] = None,
                 services: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs']] = None,
                 ssh_agent_auth: Optional[pulumi.Input[bool]] = None,
                 ssh_cert_path: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None,
                 upgrade_strategy: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs']] = None):
        if addon_job_timeout is not None:
            pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if bastion_host is not None:
            pulumi.set(__self__, "bastion_host", bastion_host)
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter(name="addonJobTimeout")
    def addon_job_timeout(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "addon_job_timeout")

    @addon_job_timeout.setter
    def addon_job_timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "addon_job_timeout", value)

    @property
    @pulumi.getter
    def addons(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "addons")

    @addons.setter
    def addons(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "addons", value)

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "addons_includes")

    @addons_includes.setter
    def addons_includes(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "addons_includes", value)

    @property
    @pulumi.getter
    def authentication(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs']]:
        return pulumi.get(self, "authentication")

    @authentication.setter
    def authentication(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs']]):
        pulumi.set(self, "authentication", value)

    @property
    @pulumi.getter
    def authorization(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs']]:
        return pulumi.get(self, "authorization")

    @authorization.setter
    def authorization(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs']]):
        pulumi.set(self, "authorization", value)

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs']]:
        return pulumi.get(self, "bastion_host")

    @bastion_host.setter
    def bastion_host(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs']]):
        pulumi.set(self, "bastion_host", value)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderArgs']]:
        return pulumi.get(self, "cloud_provider")

    @cloud_provider.setter
    def cloud_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderArgs']]):
        pulumi.set(self, "cloud_provider", value)

    @property
    @pulumi.getter
    def dns(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsArgs']]:
        return pulumi.get(self, "dns")

    @dns.setter
    def dns(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsArgs']]):
        pulumi.set(self, "dns", value)

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ignore_docker_version")

    @ignore_docker_version.setter
    def ignore_docker_version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_docker_version", value)

    @property
    @pulumi.getter
    def ingress(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs']]:
        return pulumi.get(self, "ingress")

    @ingress.setter
    def ingress(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs']]):
        pulumi.set(self, "ingress", value)

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kubernetes_version")

    @kubernetes_version.setter
    def kubernetes_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kubernetes_version", value)

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs']]:
        return pulumi.get(self, "monitoring")

    @monitoring.setter
    def monitoring(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs']]):
        pulumi.set(self, "monitoring", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs']]:
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs']]):
        pulumi.set(self, "network", value)

    @property
    @pulumi.getter
    def nodes(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs']]]]:
        return pulumi.get(self, "nodes")

    @nodes.setter
    def nodes(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs']]]]):
        pulumi.set(self, "nodes", value)

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "prefix_path")

    @prefix_path.setter
    def prefix_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_path", value)

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs']]]]:
        return pulumi.get(self, "private_registries")

    @private_registries.setter
    def private_registries(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs']]]]):
        pulumi.set(self, "private_registries", value)

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs']]:
        return pulumi.get(self, "services")

    @services.setter
    def services(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs']]):
        pulumi.set(self, "services", value)

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ssh_agent_auth")

    @ssh_agent_auth.setter
    def ssh_agent_auth(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssh_agent_auth", value)

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ssh_cert_path")

    @ssh_cert_path.setter
    def ssh_cert_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_cert_path", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs']]:
        return pulumi.get(self, "upgrade_strategy")

    @upgrade_strategy.setter
    def upgrade_strategy(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs']]):
        pulumi.set(self, "upgrade_strategy", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs:
    def __init__(__self__, *,
                 sans: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        if sans is not None:
            pulumi.set(__self__, "sans", sans)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "sans")

    @sans.setter
    def sans(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "sans", value)

    @property
    @pulumi.getter
    def strategy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "strategy", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs:
    def __init__(__self__, *,
                 mode: Optional[pulumi.Input[str]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if options is not None:
            pulumi.set(__self__, "options", options)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 user: pulumi.Input[str],
                 port: Optional[pulumi.Input[str]] = None,
                 ssh_agent_auth: Optional[pulumi.Input[bool]] = None,
                 ssh_key: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ssh_agent_auth")

    @ssh_agent_auth.setter
    def ssh_agent_auth(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssh_agent_auth", value)

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ssh_key")

    @ssh_key.setter
    def ssh_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderArgs:
    def __init__(__self__, *,
                 aws_cloud_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderArgs']] = None,
                 azure_cloud_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderArgs']] = None,
                 custom_cloud_provider: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 openstack_cloud_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderArgs']] = None,
                 vsphere_cloud_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderArgs']] = None):
        """
        :param pulumi.Input[str] name: The cluster template revision name (string)
        """
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if custom_cloud_provider is not None:
            pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderArgs']]:
        return pulumi.get(self, "aws_cloud_provider")

    @aws_cloud_provider.setter
    def aws_cloud_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderArgs']]):
        pulumi.set(self, "aws_cloud_provider", value)

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderArgs']]:
        return pulumi.get(self, "azure_cloud_provider")

    @azure_cloud_provider.setter
    def azure_cloud_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderArgs']]):
        pulumi.set(self, "azure_cloud_provider", value)

    @property
    @pulumi.getter(name="customCloudProvider")
    def custom_cloud_provider(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "custom_cloud_provider")

    @custom_cloud_provider.setter
    def custom_cloud_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_cloud_provider", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The cluster template revision name (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderArgs']]:
        return pulumi.get(self, "openstack_cloud_provider")

    @openstack_cloud_provider.setter
    def openstack_cloud_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderArgs']]):
        pulumi.set(self, "openstack_cloud_provider", value)

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderArgs']]:
        return pulumi.get(self, "vsphere_cloud_provider")

    @vsphere_cloud_provider.setter
    def vsphere_cloud_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderArgs']]):
        pulumi.set(self, "vsphere_cloud_provider", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderArgs:
    def __init__(__self__, *,
                 global_: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalArgs']] = None,
                 service_overrides: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]] = None):
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if service_overrides is not None:
            pulumi.set(__self__, "service_overrides", service_overrides)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalArgs']]:
        return pulumi.get(self, "global_")

    @global_.setter
    def global_(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalArgs']]):
        pulumi.set(self, "global_", value)

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]]:
        return pulumi.get(self, "service_overrides")

    @service_overrides.setter
    def service_overrides(self, value: Optional[pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]]):
        pulumi.set(self, "service_overrides", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 disable_security_group_ingress: Optional[pulumi.Input[bool]] = None,
                 disable_strict_zone_check: Optional[pulumi.Input[bool]] = None,
                 elb_security_group: Optional[pulumi.Input[str]] = None,
                 kubernetes_cluster_id: Optional[pulumi.Input[str]] = None,
                 kubernetes_cluster_tag: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 route_table_id: Optional[pulumi.Input[str]] = None,
                 subnet_id: Optional[pulumi.Input[str]] = None,
                 vpc: Optional[pulumi.Input[str]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        if disable_security_group_ingress is not None:
            pulumi.set(__self__, "disable_security_group_ingress", disable_security_group_ingress)
        if disable_strict_zone_check is not None:
            pulumi.set(__self__, "disable_strict_zone_check", disable_strict_zone_check)
        if elb_security_group is not None:
            pulumi.set(__self__, "elb_security_group", elb_security_group)
        if kubernetes_cluster_id is not None:
            pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        if kubernetes_cluster_tag is not None:
            pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if route_table_id is not None:
            pulumi.set(__self__, "route_table_id", route_table_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "disable_security_group_ingress")

    @disable_security_group_ingress.setter
    def disable_security_group_ingress(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_security_group_ingress", value)

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "disable_strict_zone_check")

    @disable_strict_zone_check.setter
    def disable_strict_zone_check(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_strict_zone_check", value)

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "elb_security_group")

    @elb_security_group.setter
    def elb_security_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "elb_security_group", value)

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kubernetes_cluster_id")

    @kubernetes_cluster_id.setter
    def kubernetes_cluster_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kubernetes_cluster_id", value)

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @kubernetes_cluster_tag.setter
    def kubernetes_cluster_tag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kubernetes_cluster_tag", value)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route_table_id")

    @route_table_id.setter
    def route_table_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route_table_id", value)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnet_id")

    @subnet_id.setter
    def subnet_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_id", value)

    @property
    @pulumi.getter
    def vpc(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vpc")

    @vpc.setter
    def vpc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc", value)

    @property
    @pulumi.getter
    def zone(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "zone")

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs:
    def __init__(__self__, *,
                 service: pulumi.Input[str],
                 region: Optional[pulumi.Input[str]] = None,
                 signing_method: Optional[pulumi.Input[str]] = None,
                 signing_name: Optional[pulumi.Input[str]] = None,
                 signing_region: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "service", service)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if signing_method is not None:
            pulumi.set(__self__, "signing_method", signing_method)
        if signing_name is not None:
            pulumi.set(__self__, "signing_name", signing_name)
        if signing_region is not None:
            pulumi.set(__self__, "signing_region", signing_region)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def service(self) -> pulumi.Input[str]:
        return pulumi.get(self, "service")

    @service.setter
    def service(self, value: pulumi.Input[str]):
        pulumi.set(self, "service", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "signing_method")

    @signing_method.setter
    def signing_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_method", value)

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "signing_name")

    @signing_name.setter
    def signing_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_name", value)

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "signing_region")

    @signing_region.setter
    def signing_region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_region", value)

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderArgs:
    def __init__(__self__, *,
                 aad_client_id: pulumi.Input[str],
                 aad_client_secret: pulumi.Input[str],
                 subscription_id: pulumi.Input[str],
                 tenant_id: pulumi.Input[str],
                 aad_client_cert_password: Optional[pulumi.Input[str]] = None,
                 aad_client_cert_path: Optional[pulumi.Input[str]] = None,
                 cloud: Optional[pulumi.Input[str]] = None,
                 cloud_provider_backoff: Optional[pulumi.Input[bool]] = None,
                 cloud_provider_backoff_duration: Optional[pulumi.Input[float]] = None,
                 cloud_provider_backoff_exponent: Optional[pulumi.Input[float]] = None,
                 cloud_provider_backoff_jitter: Optional[pulumi.Input[float]] = None,
                 cloud_provider_backoff_retries: Optional[pulumi.Input[float]] = None,
                 cloud_provider_rate_limit: Optional[pulumi.Input[bool]] = None,
                 cloud_provider_rate_limit_bucket: Optional[pulumi.Input[float]] = None,
                 cloud_provider_rate_limit_qps: Optional[pulumi.Input[float]] = None,
                 load_balancer_sku: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 maximum_load_balancer_rule_count: Optional[pulumi.Input[float]] = None,
                 primary_availability_set_name: Optional[pulumi.Input[str]] = None,
                 primary_scale_set_name: Optional[pulumi.Input[str]] = None,
                 resource_group: Optional[pulumi.Input[str]] = None,
                 route_table_name: Optional[pulumi.Input[str]] = None,
                 security_group_name: Optional[pulumi.Input[str]] = None,
                 subnet_name: Optional[pulumi.Input[str]] = None,
                 use_instance_metadata: Optional[pulumi.Input[bool]] = None,
                 use_managed_identity_extension: Optional[pulumi.Input[bool]] = None,
                 vm_type: Optional[pulumi.Input[str]] = None,
                 vnet_name: Optional[pulumi.Input[str]] = None,
                 vnet_resource_group: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "aad_client_id", aad_client_id)
        pulumi.set(__self__, "aad_client_secret", aad_client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if aad_client_cert_password is not None:
            pulumi.set(__self__, "aad_client_cert_password", aad_client_cert_password)
        if aad_client_cert_path is not None:
            pulumi.set(__self__, "aad_client_cert_path", aad_client_cert_path)
        if cloud is not None:
            pulumi.set(__self__, "cloud", cloud)
        if cloud_provider_backoff is not None:
            pulumi.set(__self__, "cloud_provider_backoff", cloud_provider_backoff)
        if cloud_provider_backoff_duration is not None:
            pulumi.set(__self__, "cloud_provider_backoff_duration", cloud_provider_backoff_duration)
        if cloud_provider_backoff_exponent is not None:
            pulumi.set(__self__, "cloud_provider_backoff_exponent", cloud_provider_backoff_exponent)
        if cloud_provider_backoff_jitter is not None:
            pulumi.set(__self__, "cloud_provider_backoff_jitter", cloud_provider_backoff_jitter)
        if cloud_provider_backoff_retries is not None:
            pulumi.set(__self__, "cloud_provider_backoff_retries", cloud_provider_backoff_retries)
        if cloud_provider_rate_limit is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit", cloud_provider_rate_limit)
        if cloud_provider_rate_limit_bucket is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_bucket", cloud_provider_rate_limit_bucket)
        if cloud_provider_rate_limit_qps is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_qps", cloud_provider_rate_limit_qps)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if maximum_load_balancer_rule_count is not None:
            pulumi.set(__self__, "maximum_load_balancer_rule_count", maximum_load_balancer_rule_count)
        if primary_availability_set_name is not None:
            pulumi.set(__self__, "primary_availability_set_name", primary_availability_set_name)
        if primary_scale_set_name is not None:
            pulumi.set(__self__, "primary_scale_set_name", primary_scale_set_name)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if route_table_name is not None:
            pulumi.set(__self__, "route_table_name", route_table_name)
        if security_group_name is not None:
            pulumi.set(__self__, "security_group_name", security_group_name)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)
        if use_instance_metadata is not None:
            pulumi.set(__self__, "use_instance_metadata", use_instance_metadata)
        if use_managed_identity_extension is not None:
            pulumi.set(__self__, "use_managed_identity_extension", use_managed_identity_extension)
        if vm_type is not None:
            pulumi.set(__self__, "vm_type", vm_type)
        if vnet_name is not None:
            pulumi.set(__self__, "vnet_name", vnet_name)
        if vnet_resource_group is not None:
            pulumi.set(__self__, "vnet_resource_group", vnet_resource_group)

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "aad_client_id")

    @aad_client_id.setter
    def aad_client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "aad_client_id", value)

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> pulumi.Input[str]:
        return pulumi.get(self, "aad_client_secret")

    @aad_client_secret.setter
    def aad_client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "aad_client_secret", value)

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "subscription_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "tenant_id", value)

    @property
    @pulumi.getter(name="aadClientCertPassword")
    def aad_client_cert_password(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "aad_client_cert_password")

    @aad_client_cert_password.setter
    def aad_client_cert_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aad_client_cert_password", value)

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "aad_client_cert_path")

    @aad_client_cert_path.setter
    def aad_client_cert_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aad_client_cert_path", value)

    @property
    @pulumi.getter
    def cloud(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloud")

    @cloud.setter
    def cloud(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud", value)

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "cloud_provider_backoff")

    @cloud_provider_backoff.setter
    def cloud_provider_backoff(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "cloud_provider_backoff", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @cloud_provider_backoff_duration.setter
    def cloud_provider_backoff_duration(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_duration", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @cloud_provider_backoff_exponent.setter
    def cloud_provider_backoff_exponent(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_exponent", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @cloud_provider_backoff_jitter.setter
    def cloud_provider_backoff_jitter(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_jitter", value)

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @cloud_provider_backoff_retries.setter
    def cloud_provider_backoff_retries(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_backoff_retries", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @cloud_provider_rate_limit.setter
    def cloud_provider_rate_limit(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "cloud_provider_rate_limit", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @cloud_provider_rate_limit_bucket.setter
    def cloud_provider_rate_limit_bucket(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_rate_limit_bucket", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @cloud_provider_rate_limit_qps.setter
    def cloud_provider_rate_limit_qps(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cloud_provider_rate_limit_qps", value)

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "load_balancer_sku")

    @load_balancer_sku.setter
    def load_balancer_sku(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "load_balancer_sku", value)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @maximum_load_balancer_rule_count.setter
    def maximum_load_balancer_rule_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "maximum_load_balancer_rule_count", value)

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "primary_availability_set_name")

    @primary_availability_set_name.setter
    def primary_availability_set_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "primary_availability_set_name", value)

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "primary_scale_set_name")

    @primary_scale_set_name.setter
    def primary_scale_set_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "primary_scale_set_name", value)

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resource_group")

    @resource_group.setter
    def resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_group", value)

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route_table_name")

    @route_table_name.setter
    def route_table_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route_table_name", value)

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "security_group_name")

    @security_group_name.setter
    def security_group_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "security_group_name", value)

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnet_name")

    @subnet_name.setter
    def subnet_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_name", value)

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "use_instance_metadata")

    @use_instance_metadata.setter
    def use_instance_metadata(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_instance_metadata", value)

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "use_managed_identity_extension")

    @use_managed_identity_extension.setter
    def use_managed_identity_extension(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_managed_identity_extension", value)

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vm_type")

    @vm_type.setter
    def vm_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vm_type", value)

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vnet_name")

    @vnet_name.setter
    def vnet_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vnet_name", value)

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vnet_resource_group")

    @vnet_resource_group.setter
    def vnet_resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vnet_resource_group", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderArgs:
    def __init__(__self__, *,
                 global_: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs'],
                 block_storage: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs']] = None,
                 load_balancer: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs']] = None,
                 metadata: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs']] = None,
                 route: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteArgs']] = None):
        pulumi.set(__self__, "global_", global_)
        if block_storage is not None:
            pulumi.set(__self__, "block_storage", block_storage)
        if load_balancer is not None:
            pulumi.set(__self__, "load_balancer", load_balancer)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if route is not None:
            pulumi.set(__self__, "route", route)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs']:
        return pulumi.get(self, "global_")

    @global_.setter
    def global_(self, value: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs']):
        pulumi.set(self, "global_", value)

    @property
    @pulumi.getter(name="blockStorage")
    def block_storage(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs']]:
        return pulumi.get(self, "block_storage")

    @block_storage.setter
    def block_storage(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs']]):
        pulumi.set(self, "block_storage", value)

    @property
    @pulumi.getter(name="loadBalancer")
    def load_balancer(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs']]:
        return pulumi.get(self, "load_balancer")

    @load_balancer.setter
    def load_balancer(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs']]):
        pulumi.set(self, "load_balancer", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs']]:
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs']]):
        pulumi.set(self, "metadata", value)

    @property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteArgs']]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteArgs']]):
        pulumi.set(self, "route", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs:
    def __init__(__self__, *,
                 bs_version: Optional[pulumi.Input[str]] = None,
                 ignore_volume_az: Optional[pulumi.Input[bool]] = None,
                 trust_device_path: Optional[pulumi.Input[bool]] = None):
        if bs_version is not None:
            pulumi.set(__self__, "bs_version", bs_version)
        if ignore_volume_az is not None:
            pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        if trust_device_path is not None:
            pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "bs_version")

    @bs_version.setter
    def bs_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bs_version", value)

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ignore_volume_az")

    @ignore_volume_az.setter
    def ignore_volume_az(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_volume_az", value)

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "trust_device_path")

    @trust_device_path.setter
    def trust_device_path(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "trust_device_path", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 auth_url: pulumi.Input[str],
                 password: pulumi.Input[str],
                 username: pulumi.Input[str],
                 ca_file: Optional[pulumi.Input[str]] = None,
                 domain_id: Optional[pulumi.Input[str]] = None,
                 domain_name: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None,
                 tenant_name: Optional[pulumi.Input[str]] = None,
                 trust_id: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if ca_file is not None:
            pulumi.set(__self__, "ca_file", ca_file)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if trust_id is not None:
            pulumi.set(__self__, "trust_id", trust_id)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> pulumi.Input[str]:
        return pulumi.get(self, "auth_url")

    @auth_url.setter
    def auth_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "auth_url", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ca_file")

    @ca_file.setter
    def ca_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_file", value)

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "domain_id")

    @domain_id.setter
    def domain_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_id", value)

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "domain_name")

    @domain_name.setter
    def domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_name", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tenant_name")

    @tenant_name.setter
    def tenant_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_name", value)

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "trust_id")

    @trust_id.setter
    def trust_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "trust_id", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs:
    def __init__(__self__, *,
                 create_monitor: Optional[pulumi.Input[bool]] = None,
                 floating_network_id: Optional[pulumi.Input[str]] = None,
                 lb_method: Optional[pulumi.Input[str]] = None,
                 lb_provider: Optional[pulumi.Input[str]] = None,
                 lb_version: Optional[pulumi.Input[str]] = None,
                 manage_security_groups: Optional[pulumi.Input[bool]] = None,
                 monitor_delay: Optional[pulumi.Input[str]] = None,
                 monitor_max_retries: Optional[pulumi.Input[float]] = None,
                 monitor_timeout: Optional[pulumi.Input[str]] = None,
                 subnet_id: Optional[pulumi.Input[str]] = None,
                 use_octavia: Optional[pulumi.Input[bool]] = None):
        if create_monitor is not None:
            pulumi.set(__self__, "create_monitor", create_monitor)
        if floating_network_id is not None:
            pulumi.set(__self__, "floating_network_id", floating_network_id)
        if lb_method is not None:
            pulumi.set(__self__, "lb_method", lb_method)
        if lb_provider is not None:
            pulumi.set(__self__, "lb_provider", lb_provider)
        if lb_version is not None:
            pulumi.set(__self__, "lb_version", lb_version)
        if manage_security_groups is not None:
            pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        if monitor_delay is not None:
            pulumi.set(__self__, "monitor_delay", monitor_delay)
        if monitor_max_retries is not None:
            pulumi.set(__self__, "monitor_max_retries", monitor_max_retries)
        if monitor_timeout is not None:
            pulumi.set(__self__, "monitor_timeout", monitor_timeout)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if use_octavia is not None:
            pulumi.set(__self__, "use_octavia", use_octavia)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "create_monitor")

    @create_monitor.setter
    def create_monitor(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_monitor", value)

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "floating_network_id")

    @floating_network_id.setter
    def floating_network_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "floating_network_id", value)

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "lb_method")

    @lb_method.setter
    def lb_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lb_method", value)

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "lb_provider")

    @lb_provider.setter
    def lb_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lb_provider", value)

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "lb_version")

    @lb_version.setter
    def lb_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lb_version", value)

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "manage_security_groups")

    @manage_security_groups.setter
    def manage_security_groups(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "manage_security_groups", value)

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "monitor_delay")

    @monitor_delay.setter
    def monitor_delay(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "monitor_delay", value)

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "monitor_max_retries")

    @monitor_max_retries.setter
    def monitor_max_retries(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "monitor_max_retries", value)

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "monitor_timeout")

    @monitor_timeout.setter
    def monitor_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "monitor_timeout", value)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subnet_id")

    @subnet_id.setter
    def subnet_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_id", value)

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "use_octavia")

    @use_octavia.setter
    def use_octavia(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_octavia", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs:
    def __init__(__self__, *,
                 request_timeout: Optional[pulumi.Input[float]] = None,
                 search_order: Optional[pulumi.Input[str]] = None):
        if request_timeout is not None:
            pulumi.set(__self__, "request_timeout", request_timeout)
        if search_order is not None:
            pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "request_timeout")

    @request_timeout.setter
    def request_timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "request_timeout", value)

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "search_order")

    @search_order.setter
    def search_order(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "search_order", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteArgs:
    def __init__(__self__, *,
                 router_id: Optional[pulumi.Input[str]] = None):
        if router_id is not None:
            pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "router_id")

    @router_id.setter
    def router_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "router_id", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderArgs:
    def __init__(__self__, *,
                 virtual_centers: pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]],
                 workspace: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs'],
                 disk: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskArgs']] = None,
                 global_: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalArgs']] = None,
                 network: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkArgs']] = None):
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if network is not None:
            pulumi.set(__self__, "network", network)

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]]:
        return pulumi.get(self, "virtual_centers")

    @virtual_centers.setter
    def virtual_centers(self, value: pulumi.Input[List[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]]):
        pulumi.set(self, "virtual_centers", value)

    @property
    @pulumi.getter
    def workspace(self) -> pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs']:
        return pulumi.get(self, "workspace")

    @workspace.setter
    def workspace(self, value: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs']):
        pulumi.set(self, "workspace", value)

    @property
    @pulumi.getter
    def disk(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskArgs']]:
        return pulumi.get(self, "disk")

    @disk.setter
    def disk(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskArgs']]):
        pulumi.set(self, "disk", value)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalArgs']]:
        return pulumi.get(self, "global_")

    @global_.setter
    def global_(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalArgs']]):
        pulumi.set(self, "global_", value)

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkArgs']]:
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkArgs']]):
        pulumi.set(self, "network", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskArgs:
    def __init__(__self__, *,
                 scsi_controller_type: Optional[pulumi.Input[str]] = None):
        if scsi_controller_type is not None:
            pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scsi_controller_type")

    @scsi_controller_type.setter
    def scsi_controller_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scsi_controller_type", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 datacenters: Optional[pulumi.Input[str]] = None,
                 insecure_flag: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[str]] = None,
                 soap_roundtrip_count: Optional[pulumi.Input[float]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if insecure_flag is not None:
            pulumi.set(__self__, "insecure_flag", insecure_flag)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "datacenters")

    @datacenters.setter
    def datacenters(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datacenters", value)

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "insecure_flag")

    @insecure_flag.setter
    def insecure_flag(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "insecure_flag", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "soap_roundtrip_count", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkArgs:
    def __init__(__self__, *,
                 public_network: Optional[pulumi.Input[str]] = None):
        if public_network is not None:
            pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "public_network")

    @public_network.setter
    def public_network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "public_network", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs:
    def __init__(__self__, *,
                 datacenters: pulumi.Input[str],
                 name: pulumi.Input[str],
                 password: pulumi.Input[str],
                 user: pulumi.Input[str],
                 port: Optional[pulumi.Input[str]] = None,
                 soap_roundtrip_count: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] name: The cluster template revision name (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)

    @property
    @pulumi.getter
    def datacenters(self) -> pulumi.Input[str]:
        return pulumi.get(self, "datacenters")

    @datacenters.setter
    def datacenters(self, value: pulumi.Input[str]):
        pulumi.set(self, "datacenters", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The cluster template revision name (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "soap_roundtrip_count", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs:
    def __init__(__self__, *,
                 datacenter: pulumi.Input[str],
                 folder: pulumi.Input[str],
                 server: pulumi.Input[str],
                 default_datastore: Optional[pulumi.Input[str]] = None,
                 resourcepool_path: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "server", server)
        if default_datastore is not None:
            pulumi.set(__self__, "default_datastore", default_datastore)
        if resourcepool_path is not None:
            pulumi.set(__self__, "resourcepool_path", resourcepool_path)

    @property
    @pulumi.getter
    def datacenter(self) -> pulumi.Input[str]:
        return pulumi.get(self, "datacenter")

    @datacenter.setter
    def datacenter(self, value: pulumi.Input[str]):
        pulumi.set(self, "datacenter", value)

    @property
    @pulumi.getter
    def folder(self) -> pulumi.Input[str]:
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: pulumi.Input[str]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter
    def server(self) -> pulumi.Input[str]:
        return pulumi.get(self, "server")

    @server.setter
    def server(self, value: pulumi.Input[str]):
        pulumi.set(self, "server", value)

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "default_datastore")

    @default_datastore.setter
    def default_datastore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_datastore", value)

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resourcepool_path")

    @resourcepool_path.setter
    def resourcepool_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resourcepool_path", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsArgs:
    def __init__(__self__, *,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 nodelocal: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs']] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 reverse_cidrs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 upstream_nameservers: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None):
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs']]:
        return pulumi.get(self, "nodelocal")

    @nodelocal.setter
    def nodelocal(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs']]):
        pulumi.set(self, "nodelocal", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provider", value)

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "reverse_cidrs")

    @reverse_cidrs.setter
    def reverse_cidrs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "reverse_cidrs", value)

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "upstream_nameservers")

    @upstream_nameservers.setter
    def upstream_nameservers(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "upstream_nameservers", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs:
    def __init__(__self__, *,
                 ip_address: Optional[pulumi.Input[str]] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ip_address")

    @ip_address.setter
    def ip_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ip_address", value)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs:
    def __init__(__self__, *,
                 dns_policy: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None):
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dns_policy")

    @dns_policy.setter
    def dns_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dns_policy", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provider", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs:
    def __init__(__self__, *,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 replicas: Optional[pulumi.Input[float]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs']] = None):
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "node_selector")

    @node_selector.setter
    def node_selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "node_selector", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "provider", value)

    @property
    @pulumi.getter
    def replicas(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "replicas")

    @replicas.setter
    def replicas(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "replicas", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs']]:
        return pulumi.get(self, "update_strategy")

    @update_strategy.setter
    def update_strategy(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs']]):
        pulumi.set(self, "update_strategy", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']]:
        return pulumi.get(self, "rolling_update")

    @rolling_update.setter
    def rolling_update(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']]):
        pulumi.set(self, "rolling_update", value)

    @property
    @pulumi.getter
    def strategy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "strategy", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_surge: Optional[pulumi.Input[float]] = None,
                 max_unavailable: Optional[pulumi.Input[float]] = None):
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "max_surge")

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_surge", value)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_unavailable", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs:
    def __init__(__self__, *,
                 calico_network_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderArgs']] = None,
                 canal_network_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderArgs']] = None,
                 flannel_network_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderArgs']] = None,
                 mtu: Optional[pulumi.Input[float]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 plugin: Optional[pulumi.Input[str]] = None,
                 weave_network_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs']] = None):
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderArgs']]:
        return pulumi.get(self, "calico_network_provider")

    @calico_network_provider.setter
    def calico_network_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderArgs']]):
        pulumi.set(self, "calico_network_provider", value)

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderArgs']]:
        return pulumi.get(self, "canal_network_provider")

    @canal_network_provider.setter
    def canal_network_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderArgs']]):
        pulumi.set(self, "canal_network_provider", value)

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderArgs']]:
        return pulumi.get(self, "flannel_network_provider")

    @flannel_network_provider.setter
    def flannel_network_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderArgs']]):
        pulumi.set(self, "flannel_network_provider", value)

    @property
    @pulumi.getter
    def mtu(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "mtu")

    @mtu.setter
    def mtu(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "mtu", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "options", value)

    @property
    @pulumi.getter
    def plugin(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "plugin")

    @plugin.setter
    def plugin(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "plugin", value)

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs']]:
        return pulumi.get(self, "weave_network_provider")

    @weave_network_provider.setter
    def weave_network_provider(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs']]):
        pulumi.set(self, "weave_network_provider", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderArgs:
    def __init__(__self__, *,
                 cloud_provider: Optional[pulumi.Input[str]] = None):
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloud_provider")

    @cloud_provider.setter
    def cloud_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_provider", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderArgs:
    def __init__(__self__, *,
                 iface: Optional[pulumi.Input[str]] = None):
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "iface")

    @iface.setter
    def iface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iface", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderArgs:
    def __init__(__self__, *,
                 iface: Optional[pulumi.Input[str]] = None):
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "iface")

    @iface.setter
    def iface(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iface", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str]):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 roles: pulumi.Input[List[pulumi.Input[str]]],
                 user: pulumi.Input[str],
                 docker_socket: Optional[pulumi.Input[str]] = None,
                 hostname_override: Optional[pulumi.Input[str]] = None,
                 internal_address: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 node_id: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[str]] = None,
                 ssh_agent_auth: Optional[pulumi.Input[bool]] = None,
                 ssh_key: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the cluster template revision (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter
    def roles(self) -> pulumi.Input[List[pulumi.Input[str]]]:
        return pulumi.get(self, "roles")

    @roles.setter
    def roles(self, value: pulumi.Input[List[pulumi.Input[str]]]):
        pulumi.set(self, "roles", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "docker_socket")

    @docker_socket.setter
    def docker_socket(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_socket", value)

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "hostname_override")

    @hostname_override.setter
    def hostname_override(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hostname_override", value)

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "internal_address")

    @internal_address.setter
    def internal_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "internal_address", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the cluster template revision (map)
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "node_id")

    @node_id.setter
    def node_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_id", value)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ssh_agent_auth")

    @ssh_agent_auth.setter
    def ssh_agent_auth(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssh_agent_auth", value)

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ssh_key")

    @ssh_key.setter
    def ssh_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 is_default: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "is_default")

    @is_default.setter
    def is_default(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_default", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs:
    def __init__(__self__, *,
                 etcd: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdArgs']] = None,
                 kube_api: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiArgs']] = None,
                 kube_controller: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerArgs']] = None,
                 kubelet: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletArgs']] = None,
                 kubeproxy: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyArgs']] = None,
                 scheduler: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerArgs']] = None):
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if kube_api is not None:
            pulumi.set(__self__, "kube_api", kube_api)
        if kube_controller is not None:
            pulumi.set(__self__, "kube_controller", kube_controller)
        if kubelet is not None:
            pulumi.set(__self__, "kubelet", kubelet)
        if kubeproxy is not None:
            pulumi.set(__self__, "kubeproxy", kubeproxy)
        if scheduler is not None:
            pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdArgs']]:
        return pulumi.get(self, "etcd")

    @etcd.setter
    def etcd(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdArgs']]):
        pulumi.set(self, "etcd", value)

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiArgs']]:
        return pulumi.get(self, "kube_api")

    @kube_api.setter
    def kube_api(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiArgs']]):
        pulumi.set(self, "kube_api", value)

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerArgs']]:
        return pulumi.get(self, "kube_controller")

    @kube_controller.setter
    def kube_controller(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerArgs']]):
        pulumi.set(self, "kube_controller", value)

    @property
    @pulumi.getter
    def kubelet(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletArgs']]:
        return pulumi.get(self, "kubelet")

    @kubelet.setter
    def kubelet(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletArgs']]):
        pulumi.set(self, "kubelet", value)

    @property
    @pulumi.getter
    def kubeproxy(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyArgs']]:
        return pulumi.get(self, "kubeproxy")

    @kubeproxy.setter
    def kubeproxy(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyArgs']]):
        pulumi.set(self, "kubeproxy", value)

    @property
    @pulumi.getter
    def scheduler(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerArgs']]:
        return pulumi.get(self, "scheduler")

    @scheduler.setter
    def scheduler(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerArgs']]):
        pulumi.set(self, "scheduler", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdArgs:
    def __init__(__self__, *,
                 backup_config: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs']] = None,
                 ca_cert: Optional[pulumi.Input[str]] = None,
                 cert: Optional[pulumi.Input[str]] = None,
                 creation: Optional[pulumi.Input[str]] = None,
                 external_urls: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 gid: Optional[pulumi.Input[float]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 retention: Optional[pulumi.Input[str]] = None,
                 snapshot: Optional[pulumi.Input[bool]] = None,
                 uid: Optional[pulumi.Input[float]] = None):
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs']]:
        return pulumi.get(self, "backup_config")

    @backup_config.setter
    def backup_config(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs']]):
        pulumi.set(self, "backup_config", value)

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ca_cert")

    @ca_cert.setter
    def ca_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_cert", value)

    @property
    @pulumi.getter
    def cert(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cert")

    @cert.setter
    def cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cert", value)

    @property
    @pulumi.getter
    def creation(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "creation")

    @creation.setter
    def creation(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "creation", value)

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "external_urls")

    @external_urls.setter
    def external_urls(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "external_urls", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def gid(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "gid")

    @gid.setter
    def gid(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "gid", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "retention", value)

    @property
    @pulumi.getter
    def snapshot(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "snapshot")

    @snapshot.setter
    def snapshot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "snapshot", value)

    @property
    @pulumi.getter
    def uid(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "uid")

    @uid.setter
    def uid(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "uid", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 interval_hours: Optional[pulumi.Input[float]] = None,
                 retention: Optional[pulumi.Input[float]] = None,
                 s3_backup_config: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']] = None,
                 safe_timestamp: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "interval_hours")

    @interval_hours.setter
    def interval_hours(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "interval_hours", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "retention", value)

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']]:
        return pulumi.get(self, "s3_backup_config")

    @s3_backup_config.setter
    def s3_backup_config(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']]):
        pulumi.set(self, "s3_backup_config", value)

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "safe_timestamp")

    @safe_timestamp.setter
    def safe_timestamp(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "safe_timestamp", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 endpoint: pulumi.Input[str],
                 access_key: Optional[pulumi.Input[str]] = None,
                 custom_ca: Optional[pulumi.Input[str]] = None,
                 folder: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 secret_key: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_name")

    @bucket_name.setter
    def bucket_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_name", value)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "custom_ca")

    @custom_ca.setter
    def custom_ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_ca", value)

    @property
    @pulumi.getter
    def folder(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret_key", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiArgs:
    def __init__(__self__, *,
                 admission_configuration: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 always_pull_images: Optional[pulumi.Input[bool]] = None,
                 audit_log: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs']] = None,
                 event_rate_limit: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitArgs']] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 pod_security_policy: Optional[pulumi.Input[bool]] = None,
                 secrets_encryption_config: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']] = None,
                 service_cluster_ip_range: Optional[pulumi.Input[str]] = None,
                 service_node_port_range: Optional[pulumi.Input[str]] = None):
        if admission_configuration is not None:
            pulumi.set(__self__, "admission_configuration", admission_configuration)
        if always_pull_images is not None:
            pulumi.set(__self__, "always_pull_images", always_pull_images)
        if audit_log is not None:
            pulumi.set(__self__, "audit_log", audit_log)
        if event_rate_limit is not None:
            pulumi.set(__self__, "event_rate_limit", event_rate_limit)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if service_node_port_range is not None:
            pulumi.set(__self__, "service_node_port_range", service_node_port_range)

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "admission_configuration")

    @admission_configuration.setter
    def admission_configuration(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "admission_configuration", value)

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "always_pull_images")

    @always_pull_images.setter
    def always_pull_images(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "always_pull_images", value)

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs']]:
        return pulumi.get(self, "audit_log")

    @audit_log.setter
    def audit_log(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs']]):
        pulumi.set(self, "audit_log", value)

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitArgs']]:
        return pulumi.get(self, "event_rate_limit")

    @event_rate_limit.setter
    def event_rate_limit(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitArgs']]):
        pulumi.set(self, "event_rate_limit", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "pod_security_policy")

    @pod_security_policy.setter
    def pod_security_policy(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pod_security_policy", value)

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']]:
        return pulumi.get(self, "secrets_encryption_config")

    @secrets_encryption_config.setter
    def secrets_encryption_config(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']]):
        pulumi.set(self, "secrets_encryption_config", value)

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "service_cluster_ip_range")

    @service_cluster_ip_range.setter
    def service_cluster_ip_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_cluster_ip_range", value)

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "service_node_port_range")

    @service_node_port_range.setter
    def service_node_port_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_node_port_range", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs']] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs']]:
        return pulumi.get(self, "configuration")

    @configuration.setter
    def configuration(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs']]):
        pulumi.set(self, "configuration", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs:
    def __init__(__self__, *,
                 format: Optional[pulumi.Input[str]] = None,
                 max_age: Optional[pulumi.Input[float]] = None,
                 max_backup: Optional[pulumi.Input[float]] = None,
                 max_size: Optional[pulumi.Input[float]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 policy: Optional[pulumi.Input[str]] = None):
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "format")

    @format.setter
    def format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "format", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_age", value)

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "max_backup")

    @max_backup.setter
    def max_backup(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_backup", value)

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "max_size")

    @max_size.setter
    def max_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_size", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def policy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "policy")

    @policy.setter
    def policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "policy", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "configuration")

    @configuration.setter
    def configuration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "configuration", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigArgs:
    def __init__(__self__, *,
                 custom_config: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        """
        if custom_config is not None:
            pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="customConfig")
    def custom_config(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "custom_config")

    @custom_config.setter
    def custom_config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_config", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerArgs:
    def __init__(__self__, *,
                 cluster_cidr: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 service_cluster_ip_range: Optional[pulumi.Input[str]] = None):
        if cluster_cidr is not None:
            pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_cidr")

    @cluster_cidr.setter
    def cluster_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_cidr", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "service_cluster_ip_range")

    @service_cluster_ip_range.setter
    def service_cluster_ip_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_cluster_ip_range", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletArgs:
    def __init__(__self__, *,
                 cluster_dns_server: Optional[pulumi.Input[str]] = None,
                 cluster_domain: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 fail_swap_on: Optional[pulumi.Input[bool]] = None,
                 generate_serving_certificate: Optional[pulumi.Input[bool]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 infra_container_image: Optional[pulumi.Input[str]] = None):
        if cluster_dns_server is not None:
            pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        if cluster_domain is not None:
            pulumi.set(__self__, "cluster_domain", cluster_domain)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if fail_swap_on is not None:
            pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if infra_container_image is not None:
            pulumi.set(__self__, "infra_container_image", infra_container_image)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_dns_server")

    @cluster_dns_server.setter
    def cluster_dns_server(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_dns_server", value)

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_domain")

    @cluster_domain.setter
    def cluster_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_domain", value)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "fail_swap_on")

    @fail_swap_on.setter
    def fail_swap_on(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "fail_swap_on", value)

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "generate_serving_certificate")

    @generate_serving_certificate.setter
    def generate_serving_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "generate_serving_certificate", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "infra_container_image")

    @infra_container_image.setter
    def infra_container_image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "infra_container_image", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyArgs:
    def __init__(__self__, *,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None):
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerArgs:
    def __init__(__self__, *,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 image: Optional[pulumi.Input[str]] = None):
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "extra_args")

    @extra_args.setter
    def extra_args(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "extra_args", value)

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

    @extra_binds.setter
    def extra_binds(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_binds", value)

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_envs")

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_envs", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs:
    def __init__(__self__, *,
                 drain: Optional[pulumi.Input[bool]] = None,
                 drain_input: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputArgs']] = None,
                 max_unavailable_controlplane: Optional[pulumi.Input[str]] = None,
                 max_unavailable_worker: Optional[pulumi.Input[str]] = None):
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if drain_input is not None:
            pulumi.set(__self__, "drain_input", drain_input)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

    @property
    @pulumi.getter
    def drain(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "drain")

    @drain.setter
    def drain(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drain", value)

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputArgs']]:
        return pulumi.get(self, "drain_input")

    @drain_input.setter
    def drain_input(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputArgs']]):
        pulumi.set(self, "drain_input", value)

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @max_unavailable_controlplane.setter
    def max_unavailable_controlplane(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_unavailable_controlplane", value)

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "max_unavailable_worker")

    @max_unavailable_worker.setter
    def max_unavailable_worker(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_unavailable_worker", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputArgs:
    def __init__(__self__, *,
                 delete_local_data: Optional[pulumi.Input[bool]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 grace_period: Optional[pulumi.Input[float]] = None,
                 ignore_daemon_sets: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[float]] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "delete_local_data")

    @delete_local_data.setter
    def delete_local_data(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "delete_local_data", value)

    @property
    @pulumi.getter
    def force(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "force")

    @force.setter
    def force(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force", value)

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "grace_period")

    @grace_period.setter
    def grace_period(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "grace_period", value)

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ignore_daemon_sets")

    @ignore_daemon_sets.setter
    def ignore_daemon_sets(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_daemon_sets", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs:
    def __init__(__self__, *,
                 scan_config: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigArgs'],
                 schedule_config: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigArgs'],
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable cluster template revision. Default `true` (bool)
        """
        pulumi.set(__self__, "scan_config", scan_config)
        pulumi.set(__self__, "schedule_config", schedule_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="scanConfig")
    def scan_config(self) -> pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigArgs']:
        return pulumi.get(self, "scan_config")

    @scan_config.setter
    def scan_config(self, value: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigArgs']):
        pulumi.set(self, "scan_config", value)

    @property
    @pulumi.getter(name="scheduleConfig")
    def schedule_config(self) -> pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigArgs']:
        return pulumi.get(self, "schedule_config")

    @schedule_config.setter
    def schedule_config(self, value: pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigArgs']):
        pulumi.set(self, "schedule_config", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigArgs:
    def __init__(__self__, *,
                 cis_scan_config: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigArgs']] = None):
        if cis_scan_config is not None:
            pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigArgs']]:
        return pulumi.get(self, "cis_scan_config")

    @cis_scan_config.setter
    def cis_scan_config(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigArgs']]):
        pulumi.set(self, "cis_scan_config", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigArgs:
    def __init__(__self__, *,
                 debug_master: Optional[pulumi.Input[bool]] = None,
                 debug_worker: Optional[pulumi.Input[bool]] = None,
                 override_benchmark_version: Optional[pulumi.Input[str]] = None,
                 override_skips: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 profile: Optional[pulumi.Input[str]] = None):
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="debugMaster")
    def debug_master(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "debug_master")

    @debug_master.setter
    def debug_master(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "debug_master", value)

    @property
    @pulumi.getter(name="debugWorker")
    def debug_worker(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "debug_worker")

    @debug_worker.setter
    def debug_worker(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "debug_worker", value)

    @property
    @pulumi.getter(name="overrideBenchmarkVersion")
    def override_benchmark_version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "override_benchmark_version")

    @override_benchmark_version.setter
    def override_benchmark_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "override_benchmark_version", value)

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        return pulumi.get(self, "override_skips")

    @override_skips.setter
    def override_skips(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "override_skips", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "profile", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigArgs:
    def __init__(__self__, *,
                 cron_schedule: pulumi.Input[str],
                 retention: Optional[pulumi.Input[float]] = None):
        pulumi.set(__self__, "cron_schedule", cron_schedule)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)

    @property
    @pulumi.getter(name="cronSchedule")
    def cron_schedule(self) -> pulumi.Input[str]:
        return pulumi.get(self, "cron_schedule")

    @cron_schedule.setter
    def cron_schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "cron_schedule", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "retention", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionQuestionArgs:
    def __init__(__self__, *,
                 default: pulumi.Input[str],
                 variable: pulumi.Input[str],
                 required: Optional[pulumi.Input[bool]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] default: Default variable value (string)
        :param pulumi.Input[str] variable: Variable name (string)
        :param pulumi.Input[bool] required: Required variable. Default `false` (bool)
        :param pulumi.Input[str] type: Variable type. `boolean`, `int` and `string` are allowed. Default `string` (string)
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "variable", variable)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def default(self) -> pulumi.Input[str]:
        """
        Default variable value (string)
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: pulumi.Input[str]):
        pulumi.set(self, "default", value)

    @property
    @pulumi.getter
    def variable(self) -> pulumi.Input[str]:
        """
        Variable name (string)
        """
        return pulumi.get(self, "variable")

    @variable.setter
    def variable(self, value: pulumi.Input[str]):
        pulumi.set(self, "variable", value)

    @property
    @pulumi.getter
    def required(self) -> Optional[pulumi.Input[bool]]:
        """
        Required variable. Default `false` (bool)
        """
        return pulumi.get(self, "required")

    @required.setter
    def required(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "required", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Variable type. `boolean`, `int` and `string` are allowed. Default `string` (string)
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class EtcdBackupBackupConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 interval_hours: Optional[pulumi.Input[float]] = None,
                 retention: Optional[pulumi.Input[float]] = None,
                 s3_backup_config: Optional[pulumi.Input['EtcdBackupBackupConfigS3BackupConfigArgs']] = None,
                 safe_timestamp: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable etcd backup (bool)
        :param pulumi.Input[float] interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param pulumi.Input[float] retention: Retention for etcd backup. Default `6` (int)
        :param pulumi.Input['EtcdBackupBackupConfigS3BackupConfigArgs'] s3_backup_config: S3 config options for etcd backup. Valid for `imported` and `rke` clusters. (list maxitems:1)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable etcd backup (bool)
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[pulumi.Input[float]]:
        """
        Interval hours for etcd backup. Default `12` (int)
        """
        return pulumi.get(self, "interval_hours")

    @interval_hours.setter
    def interval_hours(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "interval_hours", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[float]]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "retention", value)

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional[pulumi.Input['EtcdBackupBackupConfigS3BackupConfigArgs']]:
        """
        S3 config options for etcd backup. Valid for `imported` and `rke` clusters. (list maxitems:1)
        """
        return pulumi.get(self, "s3_backup_config")

    @s3_backup_config.setter
    def s3_backup_config(self, value: Optional[pulumi.Input['EtcdBackupBackupConfigS3BackupConfigArgs']]):
        pulumi.set(self, "s3_backup_config", value)

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "safe_timestamp")

    @safe_timestamp.setter
    def safe_timestamp(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "safe_timestamp", value)


@pulumi.input_type
class EtcdBackupBackupConfigS3BackupConfigArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 endpoint: pulumi.Input[str],
                 access_key: Optional[pulumi.Input[str]] = None,
                 custom_ca: Optional[pulumi.Input[str]] = None,
                 folder: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 secret_key: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] bucket_name: Bucket name for S3 service (string)
        :param pulumi.Input[str] endpoint: Endpoint for S3 service (string)
        :param pulumi.Input[str] access_key: Access key for S3 service (string)
        :param pulumi.Input[str] custom_ca: Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        :param pulumi.Input[str] folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param pulumi.Input[str] region: Region for S3 service (string)
        :param pulumi.Input[str] secret_key: Secret key for S3 service (string)
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        """
        Bucket name for S3 service (string)
        """
        return pulumi.get(self, "bucket_name")

    @bucket_name.setter
    def bucket_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_name", value)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint for S3 service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[str]]:
        """
        Access key for S3 service (string)
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[pulumi.Input[str]]:
        """
        Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        """
        return pulumi.get(self, "custom_ca")

    @custom_ca.setter
    def custom_ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_ca", value)

    @property
    @pulumi.getter
    def folder(self) -> Optional[pulumi.Input[str]]:
        """
        Folder for S3 service. Available from Rancher v2.2.7 (string)
        """
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        Region for S3 service (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[pulumi.Input[str]]:
        """
        Secret key for S3 service (string)
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret_key", value)


@pulumi.input_type
class MultiClusterAppAnswerArgs:
    def __init__(__self__, *,
                 cluster_id: Optional[pulumi.Input[str]] = None,
                 project_id: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] cluster_id: Cluster ID for answer (string)
        :param pulumi.Input[str] project_id: Project ID for target (string)
        :param pulumi.Input[Mapping[str, Any]] values: Key/values for answer (map)
        """
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster ID for answer (string)
        """
        return pulumi.get(self, "cluster_id")

    @cluster_id.setter
    def cluster_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[pulumi.Input[str]]:
        """
        Project ID for target (string)
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Key/values for answer (map)
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class MultiClusterAppMemberArgs:
    def __init__(__self__, *,
                 access_type: Optional[pulumi.Input[str]] = None,
                 group_principal_id: Optional[pulumi.Input[str]] = None,
                 user_principal_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_type: Member access type. Valid values: `["member" | "owner" | "read-only"]` (string)
        :param pulumi.Input[str] group_principal_id: Member group principal id (string)
        :param pulumi.Input[str] user_principal_id: Member user principal id (string)
        """
        if access_type is not None:
            pulumi.set(__self__, "access_type", access_type)
        if group_principal_id is not None:
            pulumi.set(__self__, "group_principal_id", group_principal_id)
        if user_principal_id is not None:
            pulumi.set(__self__, "user_principal_id", user_principal_id)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> Optional[pulumi.Input[str]]:
        """
        Member access type. Valid values: `["member" | "owner" | "read-only"]` (string)
        """
        return pulumi.get(self, "access_type")

    @access_type.setter
    def access_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_type", value)

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        Member group principal id (string)
        """
        return pulumi.get(self, "group_principal_id")

    @group_principal_id.setter
    def group_principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_principal_id", value)

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        Member user principal id (string)
        """
        return pulumi.get(self, "user_principal_id")

    @user_principal_id.setter
    def user_principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_principal_id", value)


@pulumi.input_type
class MultiClusterAppTargetArgs:
    def __init__(__self__, *,
                 project_id: pulumi.Input[str],
                 app_id: Optional[pulumi.Input[str]] = None,
                 health_state: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] project_id: Project ID for target (string)
        :param pulumi.Input[str] app_id: App ID for target (string)
        :param pulumi.Input[str] health_state: App health state for target (string)
        :param pulumi.Input[str] state: App state for target (string)
        """
        pulumi.set(__self__, "project_id", project_id)
        if app_id is not None:
            pulumi.set(__self__, "app_id", app_id)
        if health_state is not None:
            pulumi.set(__self__, "health_state", health_state)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        Project ID for target (string)
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> Optional[pulumi.Input[str]]:
        """
        App ID for target (string)
        """
        return pulumi.get(self, "app_id")

    @app_id.setter
    def app_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "app_id", value)

    @property
    @pulumi.getter(name="healthState")
    def health_state(self) -> Optional[pulumi.Input[str]]:
        """
        App health state for target (string)
        """
        return pulumi.get(self, "health_state")

    @health_state.setter
    def health_state(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "health_state", value)

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input[str]]:
        """
        App state for target (string)
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class MultiClusterAppUpgradeStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['MultiClusterAppUpgradeStrategyRollingUpdateArgs']] = None):
        """
        :param pulumi.Input['MultiClusterAppUpgradeStrategyRollingUpdateArgs'] rolling_update: Upgrade strategy rolling update (list MaxItems:1)
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional[pulumi.Input['MultiClusterAppUpgradeStrategyRollingUpdateArgs']]:
        """
        Upgrade strategy rolling update (list MaxItems:1)
        """
        return pulumi.get(self, "rolling_update")

    @rolling_update.setter
    def rolling_update(self, value: Optional[pulumi.Input['MultiClusterAppUpgradeStrategyRollingUpdateArgs']]):
        pulumi.set(self, "rolling_update", value)


@pulumi.input_type
class MultiClusterAppUpgradeStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 batch_size: Optional[pulumi.Input[float]] = None,
                 interval: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[float] batch_size: Rolling update batch size. Default `1` (int)
        :param pulumi.Input[float] interval: Rolling update interval. Default `1` (int)
        """
        if batch_size is not None:
            pulumi.set(__self__, "batch_size", batch_size)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)

    @property
    @pulumi.getter(name="batchSize")
    def batch_size(self) -> Optional[pulumi.Input[float]]:
        """
        Rolling update batch size. Default `1` (int)
        """
        return pulumi.get(self, "batch_size")

    @batch_size.setter
    def batch_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "batch_size", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input[float]]:
        """
        Rolling update interval. Default `1` (int)
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "interval", value)


@pulumi.input_type
class NamespaceContainerResourceLimitArgs:
    def __init__(__self__, *,
                 limits_cpu: Optional[pulumi.Input[str]] = None,
                 limits_memory: Optional[pulumi.Input[str]] = None,
                 requests_cpu: Optional[pulumi.Input[str]] = None,
                 requests_memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] limits_cpu: Limit for limits cpu in namespace (string)
        :param pulumi.Input[str] limits_memory: Limit for limits memory in namespace (string)
        :param pulumi.Input[str] requests_cpu: Limit for requests cpu in namespace (string)
        :param pulumi.Input[str] requests_memory: Limit for requests memory in namespace (string)
        """
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits cpu in namespace (string)
        """
        return pulumi.get(self, "limits_cpu")

    @limits_cpu.setter
    def limits_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_cpu", value)

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits memory in namespace (string)
        """
        return pulumi.get(self, "limits_memory")

    @limits_memory.setter
    def limits_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_memory", value)

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests cpu in namespace (string)
        """
        return pulumi.get(self, "requests_cpu")

    @requests_cpu.setter
    def requests_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_cpu", value)

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests memory in namespace (string)
        """
        return pulumi.get(self, "requests_memory")

    @requests_memory.setter
    def requests_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_memory", value)


@pulumi.input_type
class NamespaceResourceQuotaArgs:
    def __init__(__self__, *,
                 limit: pulumi.Input['NamespaceResourceQuotaLimitArgs']):
        """
        :param pulumi.Input['NamespaceResourceQuotaLimitArgs'] limit: Resource quota limit for namespace (list maxitems:1)
        """
        pulumi.set(__self__, "limit", limit)

    @property
    @pulumi.getter
    def limit(self) -> pulumi.Input['NamespaceResourceQuotaLimitArgs']:
        """
        Resource quota limit for namespace (list maxitems:1)
        """
        return pulumi.get(self, "limit")

    @limit.setter
    def limit(self, value: pulumi.Input['NamespaceResourceQuotaLimitArgs']):
        pulumi.set(self, "limit", value)


@pulumi.input_type
class NamespaceResourceQuotaLimitArgs:
    def __init__(__self__, *,
                 config_maps: Optional[pulumi.Input[str]] = None,
                 limits_cpu: Optional[pulumi.Input[str]] = None,
                 limits_memory: Optional[pulumi.Input[str]] = None,
                 persistent_volume_claims: Optional[pulumi.Input[str]] = None,
                 pods: Optional[pulumi.Input[str]] = None,
                 replication_controllers: Optional[pulumi.Input[str]] = None,
                 requests_cpu: Optional[pulumi.Input[str]] = None,
                 requests_memory: Optional[pulumi.Input[str]] = None,
                 requests_storage: Optional[pulumi.Input[str]] = None,
                 secrets: Optional[pulumi.Input[str]] = None,
                 services: Optional[pulumi.Input[str]] = None,
                 services_load_balancers: Optional[pulumi.Input[str]] = None,
                 services_node_ports: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] config_maps: Limit for config maps in namespace (string)
        :param pulumi.Input[str] limits_cpu: Limit for limits cpu in namespace (string)
        :param pulumi.Input[str] limits_memory: Limit for limits memory in namespace (string)
        :param pulumi.Input[str] persistent_volume_claims: Limit for persistent volume claims in namespace (string)
        :param pulumi.Input[str] pods: Limit for pods in namespace (string)
        :param pulumi.Input[str] replication_controllers: Limit for replication controllers in namespace (string)
        :param pulumi.Input[str] requests_cpu: Limit for requests cpu in namespace (string)
        :param pulumi.Input[str] requests_memory: Limit for requests memory in namespace (string)
        :param pulumi.Input[str] requests_storage: Limit for requests storage in namespace (string)
        :param pulumi.Input[str] secrets: Limit for secrets in namespace (string)
        :param pulumi.Input[str] services_load_balancers: Limit for services load balancers in namespace (string)
        :param pulumi.Input[str] services_node_ports: Limit for services node ports in namespace (string)
        """
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for config maps in namespace (string)
        """
        return pulumi.get(self, "config_maps")

    @config_maps.setter
    def config_maps(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config_maps", value)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits cpu in namespace (string)
        """
        return pulumi.get(self, "limits_cpu")

    @limits_cpu.setter
    def limits_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_cpu", value)

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits memory in namespace (string)
        """
        return pulumi.get(self, "limits_memory")

    @limits_memory.setter
    def limits_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_memory", value)

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for persistent volume claims in namespace (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @persistent_volume_claims.setter
    def persistent_volume_claims(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "persistent_volume_claims", value)

    @property
    @pulumi.getter
    def pods(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for pods in namespace (string)
        """
        return pulumi.get(self, "pods")

    @pods.setter
    def pods(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pods", value)

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for replication controllers in namespace (string)
        """
        return pulumi.get(self, "replication_controllers")

    @replication_controllers.setter
    def replication_controllers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "replication_controllers", value)

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests cpu in namespace (string)
        """
        return pulumi.get(self, "requests_cpu")

    @requests_cpu.setter
    def requests_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_cpu", value)

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests memory in namespace (string)
        """
        return pulumi.get(self, "requests_memory")

    @requests_memory.setter
    def requests_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_memory", value)

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests storage in namespace (string)
        """
        return pulumi.get(self, "requests_storage")

    @requests_storage.setter
    def requests_storage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_storage", value)

    @property
    @pulumi.getter
    def secrets(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for secrets in namespace (string)
        """
        return pulumi.get(self, "secrets")

    @secrets.setter
    def secrets(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secrets", value)

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "services")

    @services.setter
    def services(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services", value)

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for services load balancers in namespace (string)
        """
        return pulumi.get(self, "services_load_balancers")

    @services_load_balancers.setter
    def services_load_balancers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_load_balancers", value)

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for services node ports in namespace (string)
        """
        return pulumi.get(self, "services_node_ports")

    @services_node_ports.setter
    def services_node_ports(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_node_ports", value)


@pulumi.input_type
class NodePoolNodeTaintArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 time_added: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: Taint key (string)
        :param pulumi.Input[str] value: Taint value (string)
        :param pulumi.Input[str] effect: Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        :param pulumi.Input[str] time_added: Taint time added (string)
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if time_added is not None:
            pulumi.set(__self__, "time_added", time_added)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Taint key (string)
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        Taint value (string)
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input[str]]:
        """
        Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        """
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> Optional[pulumi.Input[str]]:
        """
        Taint time added (string)
        """
        return pulumi.get(self, "time_added")

    @time_added.setter
    def time_added(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_added", value)


@pulumi.input_type
class NodeTemplateAmazonec2ConfigArgs:
    def __init__(__self__, *,
                 ami: pulumi.Input[str],
                 region: pulumi.Input[str],
                 security_groups: pulumi.Input[List[pulumi.Input[str]]],
                 subnet_id: pulumi.Input[str],
                 vpc_id: pulumi.Input[str],
                 zone: pulumi.Input[str],
                 access_key: Optional[pulumi.Input[str]] = None,
                 block_duration_minutes: Optional[pulumi.Input[str]] = None,
                 device_name: Optional[pulumi.Input[str]] = None,
                 encrypt_ebs_volume: Optional[pulumi.Input[bool]] = None,
                 endpoint: Optional[pulumi.Input[str]] = None,
                 iam_instance_profile: Optional[pulumi.Input[str]] = None,
                 insecure_transport: Optional[pulumi.Input[bool]] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 keypair_name: Optional[pulumi.Input[str]] = None,
                 kms_key: Optional[pulumi.Input[str]] = None,
                 monitoring: Optional[pulumi.Input[bool]] = None,
                 open_ports: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 private_address_only: Optional[pulumi.Input[bool]] = None,
                 request_spot_instance: Optional[pulumi.Input[bool]] = None,
                 retries: Optional[pulumi.Input[str]] = None,
                 root_size: Optional[pulumi.Input[str]] = None,
                 secret_key: Optional[pulumi.Input[str]] = None,
                 security_group_readonly: Optional[pulumi.Input[bool]] = None,
                 session_token: Optional[pulumi.Input[str]] = None,
                 spot_price: Optional[pulumi.Input[str]] = None,
                 ssh_keypath: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[str]] = None,
                 use_ebs_optimized_instance: Optional[pulumi.Input[bool]] = None,
                 use_private_address: Optional[pulumi.Input[bool]] = None,
                 userdata: Optional[pulumi.Input[str]] = None,
                 volume_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] ami: AWS machine image (string)
        :param pulumi.Input[str] region: OpenStack region name (string)
        :param pulumi.Input[List[pulumi.Input[str]]] security_groups: AWS VPC security group. (list)
        :param pulumi.Input[str] subnet_id: AWS VPC subnet id (string)
        :param pulumi.Input[str] vpc_id: AWS VPC id. (string)
        :param pulumi.Input[str] zone: AWS zone for instance (i.e. a,b,c,d,e) (string)
        :param pulumi.Input[str] access_key: AWS access key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360). Default `0` (string)
        :param pulumi.Input[str] device_name: AWS root device name. Default `/dev/sda1` (string)
        :param pulumi.Input[bool] encrypt_ebs_volume: Encrypt EBS volume. Default `false` (bool)
        :param pulumi.Input[str] endpoint: Optional endpoint URL (hostname only or fully qualified URI) (string)
        :param pulumi.Input[str] iam_instance_profile: AWS IAM Instance Profile (string)
        :param pulumi.Input[bool] insecure_transport: Disable SSL when sending requests (bool)
        :param pulumi.Input[str] instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        :param pulumi.Input[str] keypair_name: OpenStack keypair to use to SSH to the instance (string)
        :param pulumi.Input[str] kms_key: Custom KMS key ID using the AWS Managed CMK (string)
        :param pulumi.Input[bool] monitoring: Enable monitoring for droplet. Default `false` (bool)
        :param pulumi.Input[List[pulumi.Input[str]]] open_ports: Make the specified port number accessible from the Internet. (list)
        :param pulumi.Input[bool] private_address_only: Only use a private IP address. Default `false` (bool)
        :param pulumi.Input[bool] request_spot_instance: Set this flag to request spot instance. Default `false` (bool)
        :param pulumi.Input[str] retries: Set retry count for recoverable failures (use -1 to disable). Default `5` (string)
        :param pulumi.Input[str] root_size: AWS root disk size (in GB). Default `16` (string)
        :param pulumi.Input[str] secret_key: AWS secret key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[bool] security_group_readonly: Skip adding default rules to security groups (bool)
        :param pulumi.Input[str] session_token: AWS Session Token (string)
        :param pulumi.Input[str] spot_price: AWS spot instance bid price (in dollar). Default `0.50` (string)
        :param pulumi.Input[str] ssh_keypath: SSH Key for Instance (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param pulumi.Input[bool] use_ebs_optimized_instance: Create an EBS optimized instance. Default `false` (bool)
        :param pulumi.Input[bool] use_private_address: Force the usage of private IP address. Default `false` (bool)
        :param pulumi.Input[str] userdata: Path to file with cloud-init user-data (string)
        :param pulumi.Input[str] volume_type: Amazon EBS volume type. Default `gp2` (string)
        """
        pulumi.set(__self__, "ami", ami)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "security_groups", security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "zone", zone)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if encrypt_ebs_volume is not None:
            pulumi.set(__self__, "encrypt_ebs_volume", encrypt_ebs_volume)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if insecure_transport is not None:
            pulumi.set(__self__, "insecure_transport", insecure_transport)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_address_only is not None:
            pulumi.set(__self__, "private_address_only", private_address_only)
        if request_spot_instance is not None:
            pulumi.set(__self__, "request_spot_instance", request_spot_instance)
        if retries is not None:
            pulumi.set(__self__, "retries", retries)
        if root_size is not None:
            pulumi.set(__self__, "root_size", root_size)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)
        if security_group_readonly is not None:
            pulumi.set(__self__, "security_group_readonly", security_group_readonly)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if ssh_keypath is not None:
            pulumi.set(__self__, "ssh_keypath", ssh_keypath)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if use_ebs_optimized_instance is not None:
            pulumi.set(__self__, "use_ebs_optimized_instance", use_ebs_optimized_instance)
        if use_private_address is not None:
            pulumi.set(__self__, "use_private_address", use_private_address)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def ami(self) -> pulumi.Input[str]:
        """
        AWS machine image (string)
        """
        return pulumi.get(self, "ami")

    @ami.setter
    def ami(self, value: pulumi.Input[str]):
        pulumi.set(self, "ami", value)

    @property
    @pulumi.getter
    def region(self) -> pulumi.Input[str]:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[str]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> pulumi.Input[List[pulumi.Input[str]]]:
        """
        AWS VPC security group. (list)
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: pulumi.Input[List[pulumi.Input[str]]]):
        pulumi.set(self, "security_groups", value)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> pulumi.Input[str]:
        """
        AWS VPC subnet id (string)
        """
        return pulumi.get(self, "subnet_id")

    @subnet_id.setter
    def subnet_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "subnet_id", value)

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> pulumi.Input[str]:
        """
        AWS VPC id. (string)
        """
        return pulumi.get(self, "vpc_id")

    @vpc_id.setter
    def vpc_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "vpc_id", value)

    @property
    @pulumi.getter
    def zone(self) -> pulumi.Input[str]:
        """
        AWS zone for instance (i.e. a,b,c,d,e) (string)
        """
        return pulumi.get(self, "zone")

    @zone.setter
    def zone(self, value: pulumi.Input[str]):
        pulumi.set(self, "zone", value)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[str]]:
        """
        AWS access key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[pulumi.Input[str]]:
        """
        AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360). Default `0` (string)
        """
        return pulumi.get(self, "block_duration_minutes")

    @block_duration_minutes.setter
    def block_duration_minutes(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "block_duration_minutes", value)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[pulumi.Input[str]]:
        """
        AWS root device name. Default `/dev/sda1` (string)
        """
        return pulumi.get(self, "device_name")

    @device_name.setter
    def device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "device_name", value)

    @property
    @pulumi.getter(name="encryptEbsVolume")
    def encrypt_ebs_volume(self) -> Optional[pulumi.Input[bool]]:
        """
        Encrypt EBS volume. Default `false` (bool)
        """
        return pulumi.get(self, "encrypt_ebs_volume")

    @encrypt_ebs_volume.setter
    def encrypt_ebs_volume(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "encrypt_ebs_volume", value)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Optional endpoint URL (hostname only or fully qualified URI) (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
        """
        AWS IAM Instance Profile (string)
        """
        return pulumi.get(self, "iam_instance_profile")

    @iam_instance_profile.setter
    def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iam_instance_profile", value)

    @property
    @pulumi.getter(name="insecureTransport")
    def insecure_transport(self) -> Optional[pulumi.Input[bool]]:
        """
        Disable SSL when sending requests (bool)
        """
        return pulumi.get(self, "insecure_transport")

    @insecure_transport.setter
    def insecure_transport(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "insecure_transport", value)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter(name="keypairName")
    def keypair_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack keypair to use to SSH to the instance (string)
        """
        return pulumi.get(self, "keypair_name")

    @keypair_name.setter
    def keypair_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "keypair_name", value)

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[pulumi.Input[str]]:
        """
        Custom KMS key ID using the AWS Managed CMK (string)
        """
        return pulumi.get(self, "kms_key")

    @kms_key.setter
    def kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key", value)

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable monitoring for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "monitoring")

    @monitoring.setter
    def monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "monitoring", value)

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Make the specified port number accessible from the Internet. (list)
        """
        return pulumi.get(self, "open_ports")

    @open_ports.setter
    def open_ports(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "open_ports", value)

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[pulumi.Input[bool]]:
        """
        Only use a private IP address. Default `false` (bool)
        """
        return pulumi.get(self, "private_address_only")

    @private_address_only.setter
    def private_address_only(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "private_address_only", value)

    @property
    @pulumi.getter(name="requestSpotInstance")
    def request_spot_instance(self) -> Optional[pulumi.Input[bool]]:
        """
        Set this flag to request spot instance. Default `false` (bool)
        """
        return pulumi.get(self, "request_spot_instance")

    @request_spot_instance.setter
    def request_spot_instance(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "request_spot_instance", value)

    @property
    @pulumi.getter
    def retries(self) -> Optional[pulumi.Input[str]]:
        """
        Set retry count for recoverable failures (use -1 to disable). Default `5` (string)
        """
        return pulumi.get(self, "retries")

    @retries.setter
    def retries(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "retries", value)

    @property
    @pulumi.getter(name="rootSize")
    def root_size(self) -> Optional[pulumi.Input[str]]:
        """
        AWS root disk size (in GB). Default `16` (string)
        """
        return pulumi.get(self, "root_size")

    @root_size.setter
    def root_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "root_size", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[pulumi.Input[str]]:
        """
        AWS secret key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret_key", value)

    @property
    @pulumi.getter(name="securityGroupReadonly")
    def security_group_readonly(self) -> Optional[pulumi.Input[bool]]:
        """
        Skip adding default rules to security groups (bool)
        """
        return pulumi.get(self, "security_group_readonly")

    @security_group_readonly.setter
    def security_group_readonly(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "security_group_readonly", value)

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[pulumi.Input[str]]:
        """
        AWS Session Token (string)
        """
        return pulumi.get(self, "session_token")

    @session_token.setter
    def session_token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "session_token", value)

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[pulumi.Input[str]]:
        """
        AWS spot instance bid price (in dollar). Default `0.50` (string)
        """
        return pulumi.get(self, "spot_price")

    @spot_price.setter
    def spot_price(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "spot_price", value)

    @property
    @pulumi.getter(name="sshKeypath")
    def ssh_keypath(self) -> Optional[pulumi.Input[str]]:
        """
        SSH Key for Instance (string)
        """
        return pulumi.get(self, "ssh_keypath")

    @ssh_keypath.setter
    def ssh_keypath(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_keypath", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter(name="useEbsOptimizedInstance")
    def use_ebs_optimized_instance(self) -> Optional[pulumi.Input[bool]]:
        """
        Create an EBS optimized instance. Default `false` (bool)
        """
        return pulumi.get(self, "use_ebs_optimized_instance")

    @use_ebs_optimized_instance.setter
    def use_ebs_optimized_instance(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_ebs_optimized_instance", value)

    @property
    @pulumi.getter(name="usePrivateAddress")
    def use_private_address(self) -> Optional[pulumi.Input[bool]]:
        """
        Force the usage of private IP address. Default `false` (bool)
        """
        return pulumi.get(self, "use_private_address")

    @use_private_address.setter
    def use_private_address(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_private_address", value)

    @property
    @pulumi.getter
    def userdata(self) -> Optional[pulumi.Input[str]]:
        """
        Path to file with cloud-init user-data (string)
        """
        return pulumi.get(self, "userdata")

    @userdata.setter
    def userdata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "userdata", value)

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[str]]:
        """
        Amazon EBS volume type. Default `gp2` (string)
        """
        return pulumi.get(self, "volume_type")

    @volume_type.setter
    def volume_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_type", value)


@pulumi.input_type
class NodeTemplateAzureConfigArgs:
    def __init__(__self__, *,
                 availability_set: Optional[pulumi.Input[str]] = None,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_secret: Optional[pulumi.Input[str]] = None,
                 custom_data: Optional[pulumi.Input[str]] = None,
                 disk_size: Optional[pulumi.Input[str]] = None,
                 dns: Optional[pulumi.Input[str]] = None,
                 docker_port: Optional[pulumi.Input[str]] = None,
                 environment: Optional[pulumi.Input[str]] = None,
                 fault_domain_count: Optional[pulumi.Input[str]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 managed_disks: Optional[pulumi.Input[bool]] = None,
                 no_public_ip: Optional[pulumi.Input[bool]] = None,
                 nsg: Optional[pulumi.Input[str]] = None,
                 open_ports: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 private_ip_address: Optional[pulumi.Input[str]] = None,
                 resource_group: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 static_public_ip: Optional[pulumi.Input[bool]] = None,
                 storage_type: Optional[pulumi.Input[str]] = None,
                 subnet: Optional[pulumi.Input[str]] = None,
                 subnet_prefix: Optional[pulumi.Input[str]] = None,
                 subscription_id: Optional[pulumi.Input[str]] = None,
                 update_domain_count: Optional[pulumi.Input[str]] = None,
                 use_private_ip: Optional[pulumi.Input[bool]] = None,
                 vnet: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] availability_set: Azure Availability Set to place the virtual machine into. Default `docker-machine` (string)
        :param pulumi.Input[str] client_id: Azure Service Principal Account ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] client_secret: Azure Service Principal Account password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] custom_data: Path to file with custom-data (string)
        :param pulumi.Input[str] disk_size: vSphere size of disk for docker VM (in MB). Default `20480` (string)
        :param pulumi.Input[str] dns: A unique DNS label for the public IP adddress (string)
        :param pulumi.Input[str] docker_port: Docker Port. Default `2376` (string)
        :param pulumi.Input[str] environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud). Default `AzurePublicCloud` (string)
        :param pulumi.Input[str] fault_domain_count: Fault domain count to use for availability set. Default `3` (string)
        :param pulumi.Input[str] image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param pulumi.Input[str] location: Azure region to create the virtual machine. Default `westus` (string)
        :param pulumi.Input[bool] managed_disks: Configures VM and availability set for managed disks. Just for Rancher v2.3.x and above. Default `false` (bool)
        :param pulumi.Input[bool] no_public_ip: Do not create a public IP address for the machine. Default `false` (bool)
        :param pulumi.Input[str] nsg: Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine). Default `docker-machine-nsg` (string)
        :param pulumi.Input[List[pulumi.Input[str]]] open_ports: Make the specified port number accessible from the Internet. (list)
        :param pulumi.Input[str] private_ip_address: Specify a static private IP address for the machine. (string)
        :param pulumi.Input[str] resource_group: Azure Resource Group name (will be created if missing). Default `docker-machine` (string)
        :param pulumi.Input[str] size: Digital Ocean size. Default `s-1vcpu-1gb` (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[bool] static_public_ip: Assign a static public IP address to the machine. Default `false` (bool)
        :param pulumi.Input[str] storage_type: Type of Storage Account to host the OS Disk for the machine. Default `Standard_LRS` (string)
        :param pulumi.Input[str] subnet: Azure Subnet Name to be used within the Virtual Network. Default `docker-machine` (string)
        :param pulumi.Input[str] subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918. Default `192.168.0.0/16` (string)
        :param pulumi.Input[str] subscription_id: Azure Subscription ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] update_domain_count: Update domain count to use for availability set. Default `5` (string)
        :param pulumi.Input[bool] use_private_ip: Use private IP address of the machine to connect. Default `false` (bool)
        :param pulumi.Input[str] vnet: Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format). Default `docker-machine-vnet` (string)
        """
        if availability_set is not None:
            pulumi.set(__self__, "availability_set", availability_set)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if custom_data is not None:
            pulumi.set(__self__, "custom_data", custom_data)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if fault_domain_count is not None:
            pulumi.set(__self__, "fault_domain_count", fault_domain_count)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if managed_disks is not None:
            pulumi.set(__self__, "managed_disks", managed_disks)
        if no_public_ip is not None:
            pulumi.set(__self__, "no_public_ip", no_public_ip)
        if nsg is not None:
            pulumi.set(__self__, "nsg", nsg)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if static_public_ip is not None:
            pulumi.set(__self__, "static_public_ip", static_public_ip)
        if storage_type is not None:
            pulumi.set(__self__, "storage_type", storage_type)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if subnet_prefix is not None:
            pulumi.set(__self__, "subnet_prefix", subnet_prefix)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if update_domain_count is not None:
            pulumi.set(__self__, "update_domain_count", update_domain_count)
        if use_private_ip is not None:
            pulumi.set(__self__, "use_private_ip", use_private_ip)
        if vnet is not None:
            pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="availabilitySet")
    def availability_set(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Availability Set to place the virtual machine into. Default `docker-machine` (string)
        """
        return pulumi.get(self, "availability_set")

    @availability_set.setter
    def availability_set(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "availability_set", value)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Service Principal Account ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Service Principal Account password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "client_secret")

    @client_secret.setter
    def client_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_secret", value)

    @property
    @pulumi.getter(name="customData")
    def custom_data(self) -> Optional[pulumi.Input[str]]:
        """
        Path to file with custom-data (string)
        """
        return pulumi.get(self, "custom_data")

    @custom_data.setter
    def custom_data(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_data", value)

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere size of disk for docker VM (in MB). Default `20480` (string)
        """
        return pulumi.get(self, "disk_size")

    @disk_size.setter
    def disk_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_size", value)

    @property
    @pulumi.getter
    def dns(self) -> Optional[pulumi.Input[str]]:
        """
        A unique DNS label for the public IP adddress (string)
        """
        return pulumi.get(self, "dns")

    @dns.setter
    def dns(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dns", value)

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[pulumi.Input[str]]:
        """
        Docker Port. Default `2376` (string)
        """
        return pulumi.get(self, "docker_port")

    @docker_port.setter
    def docker_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_port", value)

    @property
    @pulumi.getter
    def environment(self) -> Optional[pulumi.Input[str]]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud). Default `AzurePublicCloud` (string)
        """
        return pulumi.get(self, "environment")

    @environment.setter
    def environment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "environment", value)

    @property
    @pulumi.getter(name="faultDomainCount")
    def fault_domain_count(self) -> Optional[pulumi.Input[str]]:
        """
        Fault domain count to use for availability set. Default `3` (string)
        """
        return pulumi.get(self, "fault_domain_count")

    @fault_domain_count.setter
    def fault_domain_count(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fault_domain_count", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        """
        Azure region to create the virtual machine. Default `westus` (string)
        """
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter(name="managedDisks")
    def managed_disks(self) -> Optional[pulumi.Input[bool]]:
        """
        Configures VM and availability set for managed disks. Just for Rancher v2.3.x and above. Default `false` (bool)
        """
        return pulumi.get(self, "managed_disks")

    @managed_disks.setter
    def managed_disks(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "managed_disks", value)

    @property
    @pulumi.getter(name="noPublicIp")
    def no_public_ip(self) -> Optional[pulumi.Input[bool]]:
        """
        Do not create a public IP address for the machine. Default `false` (bool)
        """
        return pulumi.get(self, "no_public_ip")

    @no_public_ip.setter
    def no_public_ip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_public_ip", value)

    @property
    @pulumi.getter
    def nsg(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine). Default `docker-machine-nsg` (string)
        """
        return pulumi.get(self, "nsg")

    @nsg.setter
    def nsg(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nsg", value)

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Make the specified port number accessible from the Internet. (list)
        """
        return pulumi.get(self, "open_ports")

    @open_ports.setter
    def open_ports(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "open_ports", value)

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        Specify a static private IP address for the machine. (string)
        """
        return pulumi.get(self, "private_ip_address")

    @private_ip_address.setter
    def private_ip_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_ip_address", value)

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Resource Group name (will be created if missing). Default `docker-machine` (string)
        """
        return pulumi.get(self, "resource_group")

    @resource_group.setter
    def resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_group", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        Digital Ocean size. Default `s-1vcpu-1gb` (string)
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter(name="staticPublicIp")
    def static_public_ip(self) -> Optional[pulumi.Input[bool]]:
        """
        Assign a static public IP address to the machine. Default `false` (bool)
        """
        return pulumi.get(self, "static_public_ip")

    @static_public_ip.setter
    def static_public_ip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_public_ip", value)

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of Storage Account to host the OS Disk for the machine. Default `Standard_LRS` (string)
        """
        return pulumi.get(self, "storage_type")

    @storage_type.setter
    def storage_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "storage_type", value)

    @property
    @pulumi.getter
    def subnet(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Subnet Name to be used within the Virtual Network. Default `docker-machine` (string)
        """
        return pulumi.get(self, "subnet")

    @subnet.setter
    def subnet(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet", value)

    @property
    @pulumi.getter(name="subnetPrefix")
    def subnet_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        Private CIDR block to be used for the new subnet, should comply RFC 1918. Default `192.168.0.0/16` (string)
        """
        return pulumi.get(self, "subnet_prefix")

    @subnet_prefix.setter
    def subnet_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnet_prefix", value)

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Subscription ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subscription_id", value)

    @property
    @pulumi.getter(name="updateDomainCount")
    def update_domain_count(self) -> Optional[pulumi.Input[str]]:
        """
        Update domain count to use for availability set. Default `5` (string)
        """
        return pulumi.get(self, "update_domain_count")

    @update_domain_count.setter
    def update_domain_count(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "update_domain_count", value)

    @property
    @pulumi.getter(name="usePrivateIp")
    def use_private_ip(self) -> Optional[pulumi.Input[bool]]:
        """
        Use private IP address of the machine to connect. Default `false` (bool)
        """
        return pulumi.get(self, "use_private_ip")

    @use_private_ip.setter
    def use_private_ip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_private_ip", value)

    @property
    @pulumi.getter
    def vnet(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format). Default `docker-machine-vnet` (string)
        """
        return pulumi.get(self, "vnet")

    @vnet.setter
    def vnet(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vnet", value)


@pulumi.input_type
class NodeTemplateDigitaloceanConfigArgs:
    def __init__(__self__, *,
                 access_token: Optional[pulumi.Input[str]] = None,
                 backups: Optional[pulumi.Input[bool]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 ipv6: Optional[pulumi.Input[bool]] = None,
                 monitoring: Optional[pulumi.Input[bool]] = None,
                 private_networking: Optional[pulumi.Input[bool]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 ssh_key_fingerprint: Optional[pulumi.Input[str]] = None,
                 ssh_key_path: Optional[pulumi.Input[str]] = None,
                 ssh_port: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[str]] = None,
                 userdata: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_token: Digital Ocean access token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[bool] backups: Enable backups for droplet. Default `false` (bool)
        :param pulumi.Input[str] image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param pulumi.Input[bool] ipv6: Enable ipv6 for droplet. Default `false` (bool)
        :param pulumi.Input[bool] monitoring: Enable monitoring for droplet. Default `false` (bool)
        :param pulumi.Input[bool] private_networking: Enable private networking for droplet. Default `false` (bool)
        :param pulumi.Input[str] region: OpenStack region name (string)
        :param pulumi.Input[str] size: Digital Ocean size. Default `s-1vcpu-1gb` (string)
        :param pulumi.Input[str] ssh_key_fingerprint: SSH key fingerprint (string)
        :param pulumi.Input[str] ssh_key_path: SSH private key path (string)
        :param pulumi.Input[str] ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param pulumi.Input[str] userdata: Path to file with cloud-init user-data (string)
        """
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if backups is not None:
            pulumi.set(__self__, "backups", backups)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if private_networking is not None:
            pulumi.set(__self__, "private_networking", private_networking)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_key_fingerprint is not None:
            pulumi.set(__self__, "ssh_key_fingerprint", ssh_key_fingerprint)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[pulumi.Input[str]]:
        """
        Digital Ocean access token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "access_token")

    @access_token.setter
    def access_token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_token", value)

    @property
    @pulumi.getter
    def backups(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable backups for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "backups")

    @backups.setter
    def backups(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "backups", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable ipv6 for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "ipv6")

    @ipv6.setter
    def ipv6(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ipv6", value)

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable monitoring for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "monitoring")

    @monitoring.setter
    def monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "monitoring", value)

    @property
    @pulumi.getter(name="privateNetworking")
    def private_networking(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable private networking for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "private_networking")

    @private_networking.setter
    def private_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "private_networking", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        Digital Ocean size. Default `s-1vcpu-1gb` (string)
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[pulumi.Input[str]]:
        """
        SSH key fingerprint (string)
        """
        return pulumi.get(self, "ssh_key_fingerprint")

    @ssh_key_fingerprint.setter
    def ssh_key_fingerprint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_fingerprint", value)

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[pulumi.Input[str]]:
        """
        SSH private key path (string)
        """
        return pulumi.get(self, "ssh_key_path")

    @ssh_key_path.setter
    def ssh_key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_path", value)

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @ssh_port.setter
    def ssh_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_port", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def userdata(self) -> Optional[pulumi.Input[str]]:
        """
        Path to file with cloud-init user-data (string)
        """
        return pulumi.get(self, "userdata")

    @userdata.setter
    def userdata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "userdata", value)


@pulumi.input_type
class NodeTemplateLinodeConfigArgs:
    def __init__(__self__, *,
                 authorized_users: Optional[pulumi.Input[str]] = None,
                 create_private_ip: Optional[pulumi.Input[bool]] = None,
                 docker_port: Optional[pulumi.Input[str]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 root_pass: Optional[pulumi.Input[str]] = None,
                 ssh_port: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 stackscript: Optional[pulumi.Input[str]] = None,
                 stackscript_data: Optional[pulumi.Input[str]] = None,
                 swap_size: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[str]] = None,
                 token: Optional[pulumi.Input[str]] = None,
                 ua_prefix: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] authorized_users: Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node. (string)
        :param pulumi.Input[bool] create_private_ip: Create private IP for the instance. Default `false` (bool)
        :param pulumi.Input[str] docker_port: Docker Port. Default `2376` (string)
        :param pulumi.Input[str] image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param pulumi.Input[str] instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        :param pulumi.Input[str] label: Linode Instance Label. (string)
        :param pulumi.Input[str] region: OpenStack region name (string)
        :param pulumi.Input[str] root_pass: Root Password (string)
        :param pulumi.Input[str] ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] stackscript: Specifies the Linode StackScript to use to create the instance. (string)
        :param pulumi.Input[str] stackscript_data: A JSON string specifying data for the selected StackScript. (string)
        :param pulumi.Input[str] swap_size: Linode Instance Swap Size (MB). Default `512` (string)
        :param pulumi.Input[str] tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param pulumi.Input[str] token: Linode API token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] ua_prefix: Prefix the User-Agent in Linode API calls with some 'product/version' (string)
        """
        if authorized_users is not None:
            pulumi.set(__self__, "authorized_users", authorized_users)
        if create_private_ip is not None:
            pulumi.set(__self__, "create_private_ip", create_private_ip)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if root_pass is not None:
            pulumi.set(__self__, "root_pass", root_pass)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if stackscript is not None:
            pulumi.set(__self__, "stackscript", stackscript)
        if stackscript_data is not None:
            pulumi.set(__self__, "stackscript_data", stackscript_data)
        if swap_size is not None:
            pulumi.set(__self__, "swap_size", swap_size)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if ua_prefix is not None:
            pulumi.set(__self__, "ua_prefix", ua_prefix)

    @property
    @pulumi.getter(name="authorizedUsers")
    def authorized_users(self) -> Optional[pulumi.Input[str]]:
        """
        Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node. (string)
        """
        return pulumi.get(self, "authorized_users")

    @authorized_users.setter
    def authorized_users(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "authorized_users", value)

    @property
    @pulumi.getter(name="createPrivateIp")
    def create_private_ip(self) -> Optional[pulumi.Input[bool]]:
        """
        Create private IP for the instance. Default `false` (bool)
        """
        return pulumi.get(self, "create_private_ip")

    @create_private_ip.setter
    def create_private_ip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_private_ip", value)

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[pulumi.Input[str]]:
        """
        Docker Port. Default `2376` (string)
        """
        return pulumi.get(self, "docker_port")

    @docker_port.setter
    def docker_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_port", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "instance_type", value)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Linode Instance Label. (string)
        """
        return pulumi.get(self, "label")

    @label.setter
    def label(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "label", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="rootPass")
    def root_pass(self) -> Optional[pulumi.Input[str]]:
        """
        Root Password (string)
        """
        return pulumi.get(self, "root_pass")

    @root_pass.setter
    def root_pass(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "root_pass", value)

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @ssh_port.setter
    def ssh_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_port", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter
    def stackscript(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Linode StackScript to use to create the instance. (string)
        """
        return pulumi.get(self, "stackscript")

    @stackscript.setter
    def stackscript(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stackscript", value)

    @property
    @pulumi.getter(name="stackscriptData")
    def stackscript_data(self) -> Optional[pulumi.Input[str]]:
        """
        A JSON string specifying data for the selected StackScript. (string)
        """
        return pulumi.get(self, "stackscript_data")

    @stackscript_data.setter
    def stackscript_data(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stackscript_data", value)

    @property
    @pulumi.getter(name="swapSize")
    def swap_size(self) -> Optional[pulumi.Input[str]]:
        """
        Linode Instance Swap Size (MB). Default `512` (string)
        """
        return pulumi.get(self, "swap_size")

    @swap_size.setter
    def swap_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "swap_size", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[str]]:
        """
        Linode API token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token", value)

    @property
    @pulumi.getter(name="uaPrefix")
    def ua_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        Prefix the User-Agent in Linode API calls with some 'product/version' (string)
        """
        return pulumi.get(self, "ua_prefix")

    @ua_prefix.setter
    def ua_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ua_prefix", value)


@pulumi.input_type
class NodeTemplateOpennebulaConfigArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 user: pulumi.Input[str],
                 xml_rpc_url: pulumi.Input[str],
                 b2d_size: Optional[pulumi.Input[str]] = None,
                 cpu: Optional[pulumi.Input[str]] = None,
                 dev_prefix: Optional[pulumi.Input[str]] = None,
                 disable_vnc: Optional[pulumi.Input[bool]] = None,
                 disk_resize: Optional[pulumi.Input[str]] = None,
                 image_id: Optional[pulumi.Input[str]] = None,
                 image_name: Optional[pulumi.Input[str]] = None,
                 image_owner: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[str]] = None,
                 network_id: Optional[pulumi.Input[str]] = None,
                 network_name: Optional[pulumi.Input[str]] = None,
                 network_owner: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 template_id: Optional[pulumi.Input[str]] = None,
                 template_name: Optional[pulumi.Input[str]] = None,
                 vcpu: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] user: Set the user for the XML-RPC API authentication (string)
        :param pulumi.Input[str] xml_rpc_url: Set the url for the Opennebula XML-RPC API (string)
        :param pulumi.Input[str] b2d_size: Size of the Volatile disk in MB - only for b2d (string)
        :param pulumi.Input[str] cpu: CPU value for the VM (string)
        :param pulumi.Input[str] dev_prefix: Dev prefix to use for the images. E.g.: 'vd', 'sd', 'hd' (string)
        :param pulumi.Input[bool] disable_vnc: VNC is enabled by default. Disable it with this flag (bool)
        :param pulumi.Input[str] disk_resize: Size of the disk for the VM in MB (string)
        :param pulumi.Input[str] image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param pulumi.Input[str] image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param pulumi.Input[str] image_owner: Owner of the image to use as the VM OS (string)
        :param pulumi.Input[str] memory: Size of the memory for the VM in MB (string)
        :param pulumi.Input[str] network_id: Opennebula network ID to connect the machine to. Conflicts with `network_name` (string)
        :param pulumi.Input[str] network_name: Opennebula network to connect the machine to. Conflicts with `network_id` (string)
        :param pulumi.Input[str] network_owner: Opennebula user ID of the Network to connect the machine to (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] template_id: Opennebula template ID to use. Conflicts with `template_name` (string)
        :param pulumi.Input[str] template_name: Name of the Opennbula template to use. Conflicts with `template_id` (string)
        :param pulumi.Input[str] vcpu: VCPUs for the VM (string)
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        pulumi.set(__self__, "xml_rpc_url", xml_rpc_url)
        if b2d_size is not None:
            pulumi.set(__self__, "b2d_size", b2d_size)
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if dev_prefix is not None:
            pulumi.set(__self__, "dev_prefix", dev_prefix)
        if disable_vnc is not None:
            pulumi.set(__self__, "disable_vnc", disable_vnc)
        if disk_resize is not None:
            pulumi.set(__self__, "disk_resize", disk_resize)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if image_owner is not None:
            pulumi.set(__self__, "image_owner", image_owner)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if network_owner is not None:
            pulumi.set(__self__, "network_owner", network_owner)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if template_id is not None:
            pulumi.set(__self__, "template_id", template_id)
        if template_name is not None:
            pulumi.set(__self__, "template_name", template_name)
        if vcpu is not None:
            pulumi.set(__self__, "vcpu", vcpu)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def user(self) -> pulumi.Input[str]:
        """
        Set the user for the XML-RPC API authentication (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[str]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter(name="xmlRpcUrl")
    def xml_rpc_url(self) -> pulumi.Input[str]:
        """
        Set the url for the Opennebula XML-RPC API (string)
        """
        return pulumi.get(self, "xml_rpc_url")

    @xml_rpc_url.setter
    def xml_rpc_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "xml_rpc_url", value)

    @property
    @pulumi.getter(name="b2dSize")
    def b2d_size(self) -> Optional[pulumi.Input[str]]:
        """
        Size of the Volatile disk in MB - only for b2d (string)
        """
        return pulumi.get(self, "b2d_size")

    @b2d_size.setter
    def b2d_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "b2d_size", value)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[str]]:
        """
        CPU value for the VM (string)
        """
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu", value)

    @property
    @pulumi.getter(name="devPrefix")
    def dev_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        Dev prefix to use for the images. E.g.: 'vd', 'sd', 'hd' (string)
        """
        return pulumi.get(self, "dev_prefix")

    @dev_prefix.setter
    def dev_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dev_prefix", value)

    @property
    @pulumi.getter(name="disableVnc")
    def disable_vnc(self) -> Optional[pulumi.Input[bool]]:
        """
        VNC is enabled by default. Disable it with this flag (bool)
        """
        return pulumi.get(self, "disable_vnc")

    @disable_vnc.setter
    def disable_vnc(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_vnc", value)

    @property
    @pulumi.getter(name="diskResize")
    def disk_resize(self) -> Optional[pulumi.Input[str]]:
        """
        Size of the disk for the VM in MB (string)
        """
        return pulumi.get(self, "disk_resize")

    @disk_resize.setter
    def disk_resize(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_resize", value)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        """
        return pulumi.get(self, "image_id")

    @image_id.setter
    def image_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_id", value)

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        """
        return pulumi.get(self, "image_name")

    @image_name.setter
    def image_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_name", value)

    @property
    @pulumi.getter(name="imageOwner")
    def image_owner(self) -> Optional[pulumi.Input[str]]:
        """
        Owner of the image to use as the VM OS (string)
        """
        return pulumi.get(self, "image_owner")

    @image_owner.setter
    def image_owner(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_owner", value)

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[str]]:
        """
        Size of the memory for the VM in MB (string)
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory", value)

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[pulumi.Input[str]]:
        """
        Opennebula network ID to connect the machine to. Conflicts with `network_name` (string)
        """
        return pulumi.get(self, "network_id")

    @network_id.setter
    def network_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_id", value)

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[pulumi.Input[str]]:
        """
        Opennebula network to connect the machine to. Conflicts with `network_id` (string)
        """
        return pulumi.get(self, "network_name")

    @network_name.setter
    def network_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_name", value)

    @property
    @pulumi.getter(name="networkOwner")
    def network_owner(self) -> Optional[pulumi.Input[str]]:
        """
        Opennebula user ID of the Network to connect the machine to (string)
        """
        return pulumi.get(self, "network_owner")

    @network_owner.setter
    def network_owner(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_owner", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter(name="templateId")
    def template_id(self) -> Optional[pulumi.Input[str]]:
        """
        Opennebula template ID to use. Conflicts with `template_name` (string)
        """
        return pulumi.get(self, "template_id")

    @template_id.setter
    def template_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "template_id", value)

    @property
    @pulumi.getter(name="templateName")
    def template_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the Opennbula template to use. Conflicts with `template_id` (string)
        """
        return pulumi.get(self, "template_name")

    @template_name.setter
    def template_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "template_name", value)

    @property
    @pulumi.getter
    def vcpu(self) -> Optional[pulumi.Input[str]]:
        """
        VCPUs for the VM (string)
        """
        return pulumi.get(self, "vcpu")

    @vcpu.setter
    def vcpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vcpu", value)


@pulumi.input_type
class NodeTemplateOpenstackConfigArgs:
    def __init__(__self__, *,
                 auth_url: pulumi.Input[str],
                 availability_zone: pulumi.Input[str],
                 region: pulumi.Input[str],
                 username: pulumi.Input[str],
                 active_timeout: Optional[pulumi.Input[str]] = None,
                 cacert: Optional[pulumi.Input[str]] = None,
                 config_drive: Optional[pulumi.Input[bool]] = None,
                 domain_id: Optional[pulumi.Input[str]] = None,
                 domain_name: Optional[pulumi.Input[str]] = None,
                 endpoint_type: Optional[pulumi.Input[str]] = None,
                 flavor_id: Optional[pulumi.Input[str]] = None,
                 flavor_name: Optional[pulumi.Input[str]] = None,
                 floating_ip_pool: Optional[pulumi.Input[str]] = None,
                 image_id: Optional[pulumi.Input[str]] = None,
                 image_name: Optional[pulumi.Input[str]] = None,
                 insecure: Optional[pulumi.Input[bool]] = None,
                 ip_version: Optional[pulumi.Input[str]] = None,
                 keypair_name: Optional[pulumi.Input[str]] = None,
                 net_id: Optional[pulumi.Input[str]] = None,
                 net_name: Optional[pulumi.Input[str]] = None,
                 nova_network: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 private_key_file: Optional[pulumi.Input[str]] = None,
                 sec_groups: Optional[pulumi.Input[str]] = None,
                 ssh_port: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None,
                 tenant_name: Optional[pulumi.Input[str]] = None,
                 user_data_file: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] auth_url: OpenStack authentication URL (string)
        :param pulumi.Input[str] availability_zone: OpenStack availability zone (string)
        :param pulumi.Input[str] region: OpenStack region name (string)
        :param pulumi.Input[str] username: vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] active_timeout: OpenStack active timeout Default `200` (string)
        :param pulumi.Input[str] cacert: CA certificate bundle to verify against (string)
        :param pulumi.Input[bool] config_drive: Enables the OpenStack config drive for the instance. Default `false` (bool)
        :param pulumi.Input[str] domain_id: OpenStack domain ID. Identity v3 only. Conflicts with `domain_name` (string)
        :param pulumi.Input[str] domain_name: OpenStack domain name. Identity v3 only. Conflicts with `domain_id` (string)
        :param pulumi.Input[str] endpoint_type: OpenStack endpoint type. adminURL, internalURL or publicURL (string)
        :param pulumi.Input[str] flavor_id: OpenStack flavor id to use for the instance. Conflicts with `flavor_name` (string)
        :param pulumi.Input[str] flavor_name: OpenStack flavor name to use for the instance. Conflicts with `flavor_id` (string)
        :param pulumi.Input[str] floating_ip_pool: OpenStack floating IP pool to get an IP from to assign to the instance (string)
        :param pulumi.Input[str] image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param pulumi.Input[str] image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param pulumi.Input[bool] insecure: Disable TLS credential checking. Default `false` (bool)
        :param pulumi.Input[str] ip_version: OpenStack version of IP address assigned for the machine Default `4` (string)
        :param pulumi.Input[str] keypair_name: OpenStack keypair to use to SSH to the instance (string)
        :param pulumi.Input[str] net_id: OpenStack network id the machine will be connected on. Conflicts with `net_name` (string)
        :param pulumi.Input[str] net_name: OpenStack network name the machine will be connected on. Conflicts with `net_id` (string)
        :param pulumi.Input[bool] nova_network: Use the nova networking services instead of neutron (string)
        :param pulumi.Input[str] password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] private_key_file: Private key content to use for SSH (string)
        :param pulumi.Input[str] sec_groups: OpenStack comma separated security groups for the machine (string)
        :param pulumi.Input[str] ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] tenant_id: OpenStack tenant id. Conflicts with `tenant_name` (string)
        :param pulumi.Input[str] tenant_name: OpenStack tenant name. Conflicts with `tenant_id` (string)
        :param pulumi.Input[str] user_data_file: File containing an openstack userdata script (string)
        """
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "username", username)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if cacert is not None:
            pulumi.set(__self__, "cacert", cacert)
        if config_drive is not None:
            pulumi.set(__self__, "config_drive", config_drive)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if flavor_id is not None:
            pulumi.set(__self__, "flavor_id", flavor_id)
        if flavor_name is not None:
            pulumi.set(__self__, "flavor_name", flavor_name)
        if floating_ip_pool is not None:
            pulumi.set(__self__, "floating_ip_pool", floating_ip_pool)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if ip_version is not None:
            pulumi.set(__self__, "ip_version", ip_version)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if net_id is not None:
            pulumi.set(__self__, "net_id", net_id)
        if net_name is not None:
            pulumi.set(__self__, "net_name", net_name)
        if nova_network is not None:
            pulumi.set(__self__, "nova_network", nova_network)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key_file is not None:
            pulumi.set(__self__, "private_key_file", private_key_file)
        if sec_groups is not None:
            pulumi.set(__self__, "sec_groups", sec_groups)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if user_data_file is not None:
            pulumi.set(__self__, "user_data_file", user_data_file)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> pulumi.Input[str]:
        """
        OpenStack authentication URL (string)
        """
        return pulumi.get(self, "auth_url")

    @auth_url.setter
    def auth_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "auth_url", value)

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> pulumi.Input[str]:
        """
        OpenStack availability zone (string)
        """
        return pulumi.get(self, "availability_zone")

    @availability_zone.setter
    def availability_zone(self, value: pulumi.Input[str]):
        pulumi.set(self, "availability_zone", value)

    @property
    @pulumi.getter
    def region(self) -> pulumi.Input[str]:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[str]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack active timeout Default `200` (string)
        """
        return pulumi.get(self, "active_timeout")

    @active_timeout.setter
    def active_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "active_timeout", value)

    @property
    @pulumi.getter
    def cacert(self) -> Optional[pulumi.Input[str]]:
        """
        CA certificate bundle to verify against (string)
        """
        return pulumi.get(self, "cacert")

    @cacert.setter
    def cacert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cacert", value)

    @property
    @pulumi.getter(name="configDrive")
    def config_drive(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables the OpenStack config drive for the instance. Default `false` (bool)
        """
        return pulumi.get(self, "config_drive")

    @config_drive.setter
    def config_drive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "config_drive", value)

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack domain ID. Identity v3 only. Conflicts with `domain_name` (string)
        """
        return pulumi.get(self, "domain_id")

    @domain_id.setter
    def domain_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_id", value)

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack domain name. Identity v3 only. Conflicts with `domain_id` (string)
        """
        return pulumi.get(self, "domain_name")

    @domain_name.setter
    def domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_name", value)

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack endpoint type. adminURL, internalURL or publicURL (string)
        """
        return pulumi.get(self, "endpoint_type")

    @endpoint_type.setter
    def endpoint_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint_type", value)

    @property
    @pulumi.getter(name="flavorId")
    def flavor_id(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack flavor id to use for the instance. Conflicts with `flavor_name` (string)
        """
        return pulumi.get(self, "flavor_id")

    @flavor_id.setter
    def flavor_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "flavor_id", value)

    @property
    @pulumi.getter(name="flavorName")
    def flavor_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack flavor name to use for the instance. Conflicts with `flavor_id` (string)
        """
        return pulumi.get(self, "flavor_name")

    @flavor_name.setter
    def flavor_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "flavor_name", value)

    @property
    @pulumi.getter(name="floatingIpPool")
    def floating_ip_pool(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack floating IP pool to get an IP from to assign to the instance (string)
        """
        return pulumi.get(self, "floating_ip_pool")

    @floating_ip_pool.setter
    def floating_ip_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "floating_ip_pool", value)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        """
        return pulumi.get(self, "image_id")

    @image_id.setter
    def image_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_id", value)

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        """
        return pulumi.get(self, "image_name")

    @image_name.setter
    def image_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_name", value)

    @property
    @pulumi.getter
    def insecure(self) -> Optional[pulumi.Input[bool]]:
        """
        Disable TLS credential checking. Default `false` (bool)
        """
        return pulumi.get(self, "insecure")

    @insecure.setter
    def insecure(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "insecure", value)

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack version of IP address assigned for the machine Default `4` (string)
        """
        return pulumi.get(self, "ip_version")

    @ip_version.setter
    def ip_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ip_version", value)

    @property
    @pulumi.getter(name="keypairName")
    def keypair_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack keypair to use to SSH to the instance (string)
        """
        return pulumi.get(self, "keypair_name")

    @keypair_name.setter
    def keypair_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "keypair_name", value)

    @property
    @pulumi.getter(name="netId")
    def net_id(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack network id the machine will be connected on. Conflicts with `net_name` (string)
        """
        return pulumi.get(self, "net_id")

    @net_id.setter
    def net_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "net_id", value)

    @property
    @pulumi.getter(name="netName")
    def net_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack network name the machine will be connected on. Conflicts with `net_id` (string)
        """
        return pulumi.get(self, "net_name")

    @net_name.setter
    def net_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "net_name", value)

    @property
    @pulumi.getter(name="novaNetwork")
    def nova_network(self) -> Optional[pulumi.Input[bool]]:
        """
        Use the nova networking services instead of neutron (string)
        """
        return pulumi.get(self, "nova_network")

    @nova_network.setter
    def nova_network(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "nova_network", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter(name="privateKeyFile")
    def private_key_file(self) -> Optional[pulumi.Input[str]]:
        """
        Private key content to use for SSH (string)
        """
        return pulumi.get(self, "private_key_file")

    @private_key_file.setter
    def private_key_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_key_file", value)

    @property
    @pulumi.getter(name="secGroups")
    def sec_groups(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack comma separated security groups for the machine (string)
        """
        return pulumi.get(self, "sec_groups")

    @sec_groups.setter
    def sec_groups(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sec_groups", value)

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @ssh_port.setter
    def ssh_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_port", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack tenant id. Conflicts with `tenant_name` (string)
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[pulumi.Input[str]]:
        """
        OpenStack tenant name. Conflicts with `tenant_id` (string)
        """
        return pulumi.get(self, "tenant_name")

    @tenant_name.setter
    def tenant_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_name", value)

    @property
    @pulumi.getter(name="userDataFile")
    def user_data_file(self) -> Optional[pulumi.Input[str]]:
        """
        File containing an openstack userdata script (string)
        """
        return pulumi.get(self, "user_data_file")

    @user_data_file.setter
    def user_data_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_data_file", value)


@pulumi.input_type
class NodeTemplateVsphereConfigArgs:
    def __init__(__self__, *,
                 boot2docker_url: Optional[pulumi.Input[str]] = None,
                 cfgparams: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 clone_from: Optional[pulumi.Input[str]] = None,
                 cloud_config: Optional[pulumi.Input[str]] = None,
                 cloudinit: Optional[pulumi.Input[str]] = None,
                 content_library: Optional[pulumi.Input[str]] = None,
                 cpu_count: Optional[pulumi.Input[str]] = None,
                 creation_type: Optional[pulumi.Input[str]] = None,
                 custom_attributes: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 datacenter: Optional[pulumi.Input[str]] = None,
                 datastore: Optional[pulumi.Input[str]] = None,
                 datastore_cluster: Optional[pulumi.Input[str]] = None,
                 disk_size: Optional[pulumi.Input[str]] = None,
                 folder: Optional[pulumi.Input[str]] = None,
                 hostsystem: Optional[pulumi.Input[str]] = None,
                 memory_size: Optional[pulumi.Input[str]] = None,
                 networks: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 pool: Optional[pulumi.Input[str]] = None,
                 ssh_password: Optional[pulumi.Input[str]] = None,
                 ssh_port: Optional[pulumi.Input[str]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 ssh_user_group: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 username: Optional[pulumi.Input[str]] = None,
                 vapp_ip_allocation_policy: Optional[pulumi.Input[str]] = None,
                 vapp_ip_protocol: Optional[pulumi.Input[str]] = None,
                 vapp_properties: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 vapp_transport: Optional[pulumi.Input[str]] = None,
                 vcenter: Optional[pulumi.Input[str]] = None,
                 vcenter_port: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] boot2docker_url: vSphere URL for boot2docker iso image. Default `https://releases.rancher.com/os/latest/rancheros-vmware.iso` (string)
        :param pulumi.Input[List[pulumi.Input[str]]] cfgparams: vSphere vm configuration parameters (used for guestinfo) (list)
        :param pulumi.Input[str] clone_from: If you choose creation type vm (clone vm) a name of what vm you want to clone is required. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] cloudinit: vSphere cloud-init file or url to set in the guestinfo (string)
        :param pulumi.Input[str] content_library: If you choose to clone from a content library template specify the name of the library. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] cpu_count: vSphere CPU number for docker VM. Default `2` (string)
        :param pulumi.Input[str] creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy. Default `legacy`. From Rancher v2.3.3 (string)
        :param pulumi.Input[List[pulumi.Input[str]]] custom_attributes: vSphere custom attributes, format key/value e.g. `200=my custom value`. From Rancher v2.3.3 (List)
        :param pulumi.Input[str] datacenter: vSphere datacenter for docker VM (string)
        :param pulumi.Input[str] datastore: vSphere datastore for docker VM (string)
        :param pulumi.Input[str] datastore_cluster: vSphere datastore cluster for virtual machine. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] disk_size: vSphere size of disk for docker VM (in MB). Default `20480` (string)
        :param pulumi.Input[str] folder: vSphere folder for the docker VM. This folder must already exist in the datacenter (string)
        :param pulumi.Input[str] hostsystem: vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS (string)
        :param pulumi.Input[str] memory_size: vSphere size of memory for docker VM (in MB). Default `2048` (string)
        :param pulumi.Input[List[pulumi.Input[str]]] networks: vSphere network where the docker VM will be attached (list)
        :param pulumi.Input[str] password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] pool: vSphere resource pool for docker VM (string)
        :param pulumi.Input[str] ssh_password: If using a non-B2D image you can specify the ssh password. Default `tcuser`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param pulumi.Input[str] ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed. Default `staff`. From Rancher v2.3.3 (string)
        :param pulumi.Input[List[pulumi.Input[str]]] tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param pulumi.Input[str] username: vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: `dhcp`, `fixed`, `transient` and `fixedAllocated` (string)
        :param pulumi.Input[str] vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: `IPv4` and `IPv6` (string)
        :param pulumi.Input[List[pulumi.Input[str]]] vapp_properties: vSphere vApp properties (list)
        :param pulumi.Input[str] vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: `iso` and `com.vmware.guestInfo` (string)
        :param pulumi.Input[str] vcenter: vSphere IP/hostname for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param pulumi.Input[str] vcenter_port: vSphere Port for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x. Default `443` (string)
        """
        if boot2docker_url is not None:
            pulumi.set(__self__, "boot2docker_url", boot2docker_url)
        if cfgparams is not None:
            pulumi.set(__self__, "cfgparams", cfgparams)
        if clone_from is not None:
            pulumi.set(__self__, "clone_from", clone_from)
        if cloud_config is not None:
            pulumi.set(__self__, "cloud_config", cloud_config)
        if cloudinit is not None:
            pulumi.set(__self__, "cloudinit", cloudinit)
        if content_library is not None:
            pulumi.set(__self__, "content_library", content_library)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if creation_type is not None:
            pulumi.set(__self__, "creation_type", creation_type)
        if custom_attributes is not None:
            pulumi.set(__self__, "custom_attributes", custom_attributes)
        if datacenter is not None:
            pulumi.set(__self__, "datacenter", datacenter)
        if datastore is not None:
            pulumi.set(__self__, "datastore", datastore)
        if datastore_cluster is not None:
            pulumi.set(__self__, "datastore_cluster", datastore_cluster)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if hostsystem is not None:
            pulumi.set(__self__, "hostsystem", hostsystem)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if pool is not None:
            pulumi.set(__self__, "pool", pool)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if ssh_user_group is not None:
            pulumi.set(__self__, "ssh_user_group", ssh_user_group)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if vapp_ip_allocation_policy is not None:
            pulumi.set(__self__, "vapp_ip_allocation_policy", vapp_ip_allocation_policy)
        if vapp_ip_protocol is not None:
            pulumi.set(__self__, "vapp_ip_protocol", vapp_ip_protocol)
        if vapp_properties is not None:
            pulumi.set(__self__, "vapp_properties", vapp_properties)
        if vapp_transport is not None:
            pulumi.set(__self__, "vapp_transport", vapp_transport)
        if vcenter is not None:
            pulumi.set(__self__, "vcenter", vcenter)
        if vcenter_port is not None:
            pulumi.set(__self__, "vcenter_port", vcenter_port)

    @property
    @pulumi.getter(name="boot2dockerUrl")
    def boot2docker_url(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere URL for boot2docker iso image. Default `https://releases.rancher.com/os/latest/rancheros-vmware.iso` (string)
        """
        return pulumi.get(self, "boot2docker_url")

    @boot2docker_url.setter
    def boot2docker_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "boot2docker_url", value)

    @property
    @pulumi.getter
    def cfgparams(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        vSphere vm configuration parameters (used for guestinfo) (list)
        """
        return pulumi.get(self, "cfgparams")

    @cfgparams.setter
    def cfgparams(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "cfgparams", value)

    @property
    @pulumi.getter(name="cloneFrom")
    def clone_from(self) -> Optional[pulumi.Input[str]]:
        """
        If you choose creation type vm (clone vm) a name of what vm you want to clone is required. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "clone_from")

    @clone_from.setter
    def clone_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "clone_from", value)

    @property
    @pulumi.getter(name="cloudConfig")
    def cloud_config(self) -> Optional[pulumi.Input[str]]:
        """
        Filepath to a cloud-config yaml file to put into the ISO user-data. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "cloud_config")

    @cloud_config.setter
    def cloud_config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_config", value)

    @property
    @pulumi.getter
    def cloudinit(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere cloud-init file or url to set in the guestinfo (string)
        """
        return pulumi.get(self, "cloudinit")

    @cloudinit.setter
    def cloudinit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloudinit", value)

    @property
    @pulumi.getter(name="contentLibrary")
    def content_library(self) -> Optional[pulumi.Input[str]]:
        """
        If you choose to clone from a content library template specify the name of the library. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "content_library")

    @content_library.setter
    def content_library(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "content_library", value)

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere CPU number for docker VM. Default `2` (string)
        """
        return pulumi.get(self, "cpu_count")

    @cpu_count.setter
    def cpu_count(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_count", value)

    @property
    @pulumi.getter(name="creationType")
    def creation_type(self) -> Optional[pulumi.Input[str]]:
        """
        Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy. Default `legacy`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "creation_type")

    @creation_type.setter
    def creation_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "creation_type", value)

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        vSphere custom attributes, format key/value e.g. `200=my custom value`. From Rancher v2.3.3 (List)
        """
        return pulumi.get(self, "custom_attributes")

    @custom_attributes.setter
    def custom_attributes(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "custom_attributes", value)

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere datacenter for docker VM (string)
        """
        return pulumi.get(self, "datacenter")

    @datacenter.setter
    def datacenter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datacenter", value)

    @property
    @pulumi.getter
    def datastore(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere datastore for docker VM (string)
        """
        return pulumi.get(self, "datastore")

    @datastore.setter
    def datastore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datastore", value)

    @property
    @pulumi.getter(name="datastoreCluster")
    def datastore_cluster(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere datastore cluster for virtual machine. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "datastore_cluster")

    @datastore_cluster.setter
    def datastore_cluster(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datastore_cluster", value)

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere size of disk for docker VM (in MB). Default `20480` (string)
        """
        return pulumi.get(self, "disk_size")

    @disk_size.setter
    def disk_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_size", value)

    @property
    @pulumi.getter
    def folder(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere folder for the docker VM. This folder must already exist in the datacenter (string)
        """
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter
    def hostsystem(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS (string)
        """
        return pulumi.get(self, "hostsystem")

    @hostsystem.setter
    def hostsystem(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hostsystem", value)

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere size of memory for docker VM (in MB). Default `2048` (string)
        """
        return pulumi.get(self, "memory_size")

    @memory_size.setter
    def memory_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_size", value)

    @property
    @pulumi.getter
    def networks(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        vSphere network where the docker VM will be attached (list)
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "networks", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def pool(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere resource pool for docker VM (string)
        """
        return pulumi.get(self, "pool")

    @pool.setter
    def pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pool", value)

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh password. Default `tcuser`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_password")

    @ssh_password.setter
    def ssh_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_password", value)

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @ssh_port.setter
    def ssh_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_port", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter(name="sshUserGroup")
    def ssh_user_group(self) -> Optional[pulumi.Input[str]]:
        """
        If using a non-B2D image the uploaded keys will need chown'ed. Default `staff`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user_group")

    @ssh_user_group.setter
    def ssh_user_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_user_group", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="vappIpAllocationPolicy")
    def vapp_ip_allocation_policy(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere vApp IP allocation policy. Supported values are: `dhcp`, `fixed`, `transient` and `fixedAllocated` (string)
        """
        return pulumi.get(self, "vapp_ip_allocation_policy")

    @vapp_ip_allocation_policy.setter
    def vapp_ip_allocation_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vapp_ip_allocation_policy", value)

    @property
    @pulumi.getter(name="vappIpProtocol")
    def vapp_ip_protocol(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere vApp IP protocol for this deployment. Supported values are: `IPv4` and `IPv6` (string)
        """
        return pulumi.get(self, "vapp_ip_protocol")

    @vapp_ip_protocol.setter
    def vapp_ip_protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vapp_ip_protocol", value)

    @property
    @pulumi.getter(name="vappProperties")
    def vapp_properties(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        vSphere vApp properties (list)
        """
        return pulumi.get(self, "vapp_properties")

    @vapp_properties.setter
    def vapp_properties(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "vapp_properties", value)

    @property
    @pulumi.getter(name="vappTransport")
    def vapp_transport(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere OVF environment transports to use for properties. Supported values are: `iso` and `com.vmware.guestInfo` (string)
        """
        return pulumi.get(self, "vapp_transport")

    @vapp_transport.setter
    def vapp_transport(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vapp_transport", value)

    @property
    @pulumi.getter
    def vcenter(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere IP/hostname for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "vcenter")

    @vcenter.setter
    def vcenter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vcenter", value)

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere Port for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x. Default `443` (string)
        """
        return pulumi.get(self, "vcenter_port")

    @vcenter_port.setter
    def vcenter_port(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vcenter_port", value)


@pulumi.input_type
class NotifierPagerdutyConfigArgs:
    def __init__(__self__, *,
                 service_key: pulumi.Input[str],
                 proxy_url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] service_key: Pagerduty service key (string)
        :param pulumi.Input[str] proxy_url: Wechat proxy url (string)
        """
        pulumi.set(__self__, "service_key", service_key)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="serviceKey")
    def service_key(self) -> pulumi.Input[str]:
        """
        Pagerduty service key (string)
        """
        return pulumi.get(self, "service_key")

    @service_key.setter
    def service_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_key", value)

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[pulumi.Input[str]]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    @proxy_url.setter
    def proxy_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_url", value)


@pulumi.input_type
class NotifierSlackConfigArgs:
    def __init__(__self__, *,
                 default_recipient: pulumi.Input[str],
                 url: pulumi.Input[str],
                 proxy_url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] default_recipient: Wechat default recipient (string)
        :param pulumi.Input[str] url: Webhook url (string)
        :param pulumi.Input[str] proxy_url: Wechat proxy url (string)
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> pulumi.Input[str]:
        """
        Wechat default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @default_recipient.setter
    def default_recipient(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_recipient", value)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Webhook url (string)
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[pulumi.Input[str]]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    @proxy_url.setter
    def proxy_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_url", value)


@pulumi.input_type
class NotifierSmtpConfigArgs:
    def __init__(__self__, *,
                 default_recipient: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[float],
                 sender: pulumi.Input[str],
                 password: Optional[pulumi.Input[str]] = None,
                 tls: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] default_recipient: Wechat default recipient (string)
        :param pulumi.Input[str] host: SMTP host (string)
        :param pulumi.Input[float] port: SMTP port (int)
        :param pulumi.Input[str] sender: SMTP sender (string)
        :param pulumi.Input[str] password: SMTP password (string)
        :param pulumi.Input[bool] tls: SMTP tls. Default `true` (bool)
        :param pulumi.Input[str] username: SMTP username (string)
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "sender", sender)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> pulumi.Input[str]:
        """
        Wechat default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @default_recipient.setter
    def default_recipient(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_recipient", value)

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        SMTP host (string)
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[float]:
        """
        SMTP port (int)
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[float]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter
    def sender(self) -> pulumi.Input[str]:
        """
        SMTP sender (string)
        """
        return pulumi.get(self, "sender")

    @sender.setter
    def sender(self, value: pulumi.Input[str]):
        pulumi.set(self, "sender", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        SMTP password (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def tls(self) -> Optional[pulumi.Input[bool]]:
        """
        SMTP tls. Default `true` (bool)
        """
        return pulumi.get(self, "tls")

    @tls.setter
    def tls(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "tls", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        SMTP username (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class NotifierWebhookConfigArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 proxy_url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] url: Webhook url (string)
        :param pulumi.Input[str] proxy_url: Wechat proxy url (string)
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Webhook url (string)
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[pulumi.Input[str]]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    @proxy_url.setter
    def proxy_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_url", value)


@pulumi.input_type
class NotifierWechatConfigArgs:
    def __init__(__self__, *,
                 agent: pulumi.Input[str],
                 corp: pulumi.Input[str],
                 default_recipient: pulumi.Input[str],
                 secret: pulumi.Input[str],
                 proxy_url: Optional[pulumi.Input[str]] = None,
                 recipient_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] agent: Wechat agent ID (string)
        :param pulumi.Input[str] corp: Wechat corporation ID (string)
        :param pulumi.Input[str] default_recipient: Wechat default recipient (string)
        :param pulumi.Input[str] secret: Wechat agent ID (string)
        :param pulumi.Input[str] proxy_url: Wechat proxy url (string)
        :param pulumi.Input[str] recipient_type: Wechat recipient type. Allowed values: `party` | `tag` | `user` (string)
        """
        pulumi.set(__self__, "agent", agent)
        pulumi.set(__self__, "corp", corp)
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "secret", secret)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if recipient_type is not None:
            pulumi.set(__self__, "recipient_type", recipient_type)

    @property
    @pulumi.getter
    def agent(self) -> pulumi.Input[str]:
        """
        Wechat agent ID (string)
        """
        return pulumi.get(self, "agent")

    @agent.setter
    def agent(self, value: pulumi.Input[str]):
        pulumi.set(self, "agent", value)

    @property
    @pulumi.getter
    def corp(self) -> pulumi.Input[str]:
        """
        Wechat corporation ID (string)
        """
        return pulumi.get(self, "corp")

    @corp.setter
    def corp(self, value: pulumi.Input[str]):
        pulumi.set(self, "corp", value)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> pulumi.Input[str]:
        """
        Wechat default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @default_recipient.setter
    def default_recipient(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_recipient", value)

    @property
    @pulumi.getter
    def secret(self) -> pulumi.Input[str]:
        """
        Wechat agent ID (string)
        """
        return pulumi.get(self, "secret")

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[pulumi.Input[str]]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    @proxy_url.setter
    def proxy_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "proxy_url", value)

    @property
    @pulumi.getter(name="recipientType")
    def recipient_type(self) -> Optional[pulumi.Input[str]]:
        """
        Wechat recipient type. Allowed values: `party` | `tag` | `user` (string)
        """
        return pulumi.get(self, "recipient_type")

    @recipient_type.setter
    def recipient_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recipient_type", value)


@pulumi.input_type
class PodSecurityPolicyTemplateAllowedCsiDriverArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the PodSecurityPolicyTemplate (string)
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the PodSecurityPolicyTemplate (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PodSecurityPolicyTemplateAllowedFlexVolumeArgs:
    def __init__(__self__, *,
                 driver: pulumi.Input[str]):
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> pulumi.Input[str]:
        return pulumi.get(self, "driver")

    @driver.setter
    def driver(self, value: pulumi.Input[str]):
        pulumi.set(self, "driver", value)


@pulumi.input_type
class PodSecurityPolicyTemplateAllowedHostPathArgs:
    def __init__(__self__, *,
                 path_prefix: pulumi.Input[str],
                 read_only: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] path_prefix: (string)
        :param pulumi.Input[bool] read_only: (string)
        """
        pulumi.set(__self__, "path_prefix", path_prefix)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="pathPrefix")
    def path_prefix(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "path_prefix")

    @path_prefix.setter
    def path_prefix(self, value: pulumi.Input[str]):
        pulumi.set(self, "path_prefix", value)

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[pulumi.Input[bool]]:
        """
        (string)
        """
        return pulumi.get(self, "read_only")

    @read_only.setter
    def read_only(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "read_only", value)


@pulumi.input_type
class PodSecurityPolicyTemplateFsGroupArgs:
    def __init__(__self__, *,
                 ranges: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]]] = None,
                 rule: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]] ranges: (list)
        :param pulumi.Input[str] rule: (string)
        """
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]]]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]]]):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rule", value)


@pulumi.input_type
class PodSecurityPolicyTemplateFsGroupRangeArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[float],
                 min: pulumi.Input[float]):
        """
        :param pulumi.Input[float] max: (int)
        :param pulumi.Input[float] min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[float]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[float]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateHostPortArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[float],
                 min: pulumi.Input[float]):
        """
        :param pulumi.Input[float] max: (int)
        :param pulumi.Input[float] min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[float]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[float]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsGroupArgs:
    def __init__(__self__, *,
                 rule: pulumi.Input[str],
                 ranges: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]]] = None):
        """
        :param pulumi.Input[str] rule: (string)
        :param pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]] ranges: (list)
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: pulumi.Input[str]):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]]]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]]]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsGroupRangeArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[float],
                 min: pulumi.Input[float]):
        """
        :param pulumi.Input[float] max: (int)
        :param pulumi.Input[float] min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[float]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[float]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsUserArgs:
    def __init__(__self__, *,
                 rule: pulumi.Input[str],
                 ranges: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]]] = None):
        """
        :param pulumi.Input[str] rule: (string)
        :param pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]] ranges: (list)
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: pulumi.Input[str]):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]]]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]]]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsUserRangeArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[float],
                 min: pulumi.Input[float]):
        """
        :param pulumi.Input[float] max: (int)
        :param pulumi.Input[float] min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[float]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[float]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRuntimeClassArgs:
    def __init__(__self__, *,
                 allowed_runtime_class_names: pulumi.Input[List[pulumi.Input[str]]],
                 default_runtime_class_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[List[pulumi.Input[str]]] allowed_runtime_class_names: (list)
        :param pulumi.Input[str] default_runtime_class_name: (string)
        """
        pulumi.set(__self__, "allowed_runtime_class_names", allowed_runtime_class_names)
        if default_runtime_class_name is not None:
            pulumi.set(__self__, "default_runtime_class_name", default_runtime_class_name)

    @property
    @pulumi.getter(name="allowedRuntimeClassNames")
    def allowed_runtime_class_names(self) -> pulumi.Input[List[pulumi.Input[str]]]:
        """
        (list)
        """
        return pulumi.get(self, "allowed_runtime_class_names")

    @allowed_runtime_class_names.setter
    def allowed_runtime_class_names(self, value: pulumi.Input[List[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_runtime_class_names", value)

    @property
    @pulumi.getter(name="defaultRuntimeClassName")
    def default_runtime_class_name(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "default_runtime_class_name")

    @default_runtime_class_name.setter
    def default_runtime_class_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_runtime_class_name", value)


@pulumi.input_type
class PodSecurityPolicyTemplateSeLinuxArgs:
    def __init__(__self__, *,
                 rule: pulumi.Input[str],
                 se_linux_option: Optional[pulumi.Input['PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs']] = None):
        """
        :param pulumi.Input[str] rule: (string)
        :param pulumi.Input['PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs'] se_linux_option: (list maxitems:1)
        """
        pulumi.set(__self__, "rule", rule)
        if se_linux_option is not None:
            pulumi.set(__self__, "se_linux_option", se_linux_option)

    @property
    @pulumi.getter
    def rule(self) -> pulumi.Input[str]:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: pulumi.Input[str]):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter(name="seLinuxOption")
    def se_linux_option(self) -> Optional[pulumi.Input['PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs']]:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "se_linux_option")

    @se_linux_option.setter
    def se_linux_option(self, value: Optional[pulumi.Input['PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs']]):
        pulumi.set(self, "se_linux_option", value)


@pulumi.input_type
class PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs:
    def __init__(__self__, *,
                 level: Optional[pulumi.Input[str]] = None,
                 role: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] level: (string)
        :param pulumi.Input[str] role: (string)
        :param pulumi.Input[str] type: (string)
        :param pulumi.Input[str] user: (string)
        """
        if level is not None:
            pulumi.set(__self__, "level", level)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def level(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "level")

    @level.setter
    def level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "level", value)

    @property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "role")

    @role.setter
    def role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class PodSecurityPolicyTemplateSupplementalGroupArgs:
    def __init__(__self__, *,
                 ranges: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]]] = None,
                 rule: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]] ranges: (list)
        :param pulumi.Input[str] rule: (string)
        """
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]]]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[List[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]]]):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[pulumi.Input[str]]:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rule", value)


@pulumi.input_type
class PodSecurityPolicyTemplateSupplementalGroupRangeArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[float],
                 min: pulumi.Input[float]):
        """
        :param pulumi.Input[float] max: (int)
        :param pulumi.Input[float] min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[float]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[float]:
        """
        (int)
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[float]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class ProjectAlertGroupRecipientArgs:
    def __init__(__self__, *,
                 notifier_id: pulumi.Input[str],
                 default_recipient: Optional[pulumi.Input[bool]] = None,
                 notifier_type: Optional[pulumi.Input[str]] = None,
                 recipient: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] notifier_id: Recipient notifier ID (string)
        :param pulumi.Input[str] notifier_type: Recipient notifier ID. Supported values : `"pagerduty" | "slack" | "email" | "webhook" | "wechat"` (string)
        :param pulumi.Input[str] recipient: Recipient (string)
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)
        if notifier_type is not None:
            pulumi.set(__self__, "notifier_type", notifier_type)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> pulumi.Input[str]:
        """
        Recipient notifier ID (string)
        """
        return pulumi.get(self, "notifier_id")

    @notifier_id.setter
    def notifier_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "notifier_id", value)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "default_recipient")

    @default_recipient.setter
    def default_recipient(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "default_recipient", value)

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> Optional[pulumi.Input[str]]:
        """
        Recipient notifier ID. Supported values : `"pagerduty" | "slack" | "email" | "webhook" | "wechat"` (string)
        """
        return pulumi.get(self, "notifier_type")

    @notifier_type.setter
    def notifier_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "notifier_type", value)

    @property
    @pulumi.getter
    def recipient(self) -> Optional[pulumi.Input[str]]:
        """
        Recipient (string)
        """
        return pulumi.get(self, "recipient")

    @recipient.setter
    def recipient(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recipient", value)


@pulumi.input_type
class ProjectAlertRuleMetricRuleArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[str],
                 expression: pulumi.Input[str],
                 threshold_value: pulumi.Input[float],
                 comparison: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] duration: Metric rule duration (string)
        :param pulumi.Input[str] expression: Metric rule expression (string)
        :param pulumi.Input[float] threshold_value: Metric rule threshold value (float64)
        :param pulumi.Input[str] comparison: Metric rule comparison. Supported values : `"equal" | "greater-or-equal" | "greater-than" | "less-or-equal" | "less-than" | "not-equal" | "has-value"`. Default: `equal`  (string)
        :param pulumi.Input[str] description: Metric rule description (string)
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[str]:
        """
        Metric rule duration (string)
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: pulumi.Input[str]):
        pulumi.set(self, "duration", value)

    @property
    @pulumi.getter
    def expression(self) -> pulumi.Input[str]:
        """
        Metric rule expression (string)
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: pulumi.Input[str]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> pulumi.Input[float]:
        """
        Metric rule threshold value (float64)
        """
        return pulumi.get(self, "threshold_value")

    @threshold_value.setter
    def threshold_value(self, value: pulumi.Input[float]):
        pulumi.set(self, "threshold_value", value)

    @property
    @pulumi.getter
    def comparison(self) -> Optional[pulumi.Input[str]]:
        """
        Metric rule comparison. Supported values : `"equal" | "greater-or-equal" | "greater-than" | "less-or-equal" | "less-than" | "not-equal" | "has-value"`. Default: `equal`  (string)
        """
        return pulumi.get(self, "comparison")

    @comparison.setter
    def comparison(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "comparison", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Metric rule description (string)
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ProjectAlertRulePodRuleArgs:
    def __init__(__self__, *,
                 pod_id: pulumi.Input[str],
                 condition: Optional[pulumi.Input[str]] = None,
                 restart_interval_seconds: Optional[pulumi.Input[float]] = None,
                 restart_times: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] pod_id: Pod ID (string)
        :param pulumi.Input[str] condition: Pod rule condition. Supported values : `"notrunning" | "notscheduled" | "restarts"`. Default: `notrunning` (string)
        :param pulumi.Input[float] restart_interval_seconds: Pod rule restart interval seconds. Default: `300` (int)
        :param pulumi.Input[float] restart_times: Pod rule restart times. Default: `3`  (int)
        """
        pulumi.set(__self__, "pod_id", pod_id)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if restart_interval_seconds is not None:
            pulumi.set(__self__, "restart_interval_seconds", restart_interval_seconds)
        if restart_times is not None:
            pulumi.set(__self__, "restart_times", restart_times)

    @property
    @pulumi.getter(name="podId")
    def pod_id(self) -> pulumi.Input[str]:
        """
        Pod ID (string)
        """
        return pulumi.get(self, "pod_id")

    @pod_id.setter
    def pod_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "pod_id", value)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        Pod rule condition. Supported values : `"notrunning" | "notscheduled" | "restarts"`. Default: `notrunning` (string)
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)

    @property
    @pulumi.getter(name="restartIntervalSeconds")
    def restart_interval_seconds(self) -> Optional[pulumi.Input[float]]:
        """
        Pod rule restart interval seconds. Default: `300` (int)
        """
        return pulumi.get(self, "restart_interval_seconds")

    @restart_interval_seconds.setter
    def restart_interval_seconds(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "restart_interval_seconds", value)

    @property
    @pulumi.getter(name="restartTimes")
    def restart_times(self) -> Optional[pulumi.Input[float]]:
        """
        Pod rule restart times. Default: `3`  (int)
        """
        return pulumi.get(self, "restart_times")

    @restart_times.setter
    def restart_times(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "restart_times", value)


@pulumi.input_type
class ProjectAlertRuleWorkloadRuleArgs:
    def __init__(__self__, *,
                 available_percentage: Optional[pulumi.Input[float]] = None,
                 selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 workload_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] available_percentage: Workload rule available percentage. Default: `70` (int)
        :param pulumi.Input[Mapping[str, Any]] selector: Workload rule selector (map)
        :param pulumi.Input[str] workload_id: Workload ID (string)
        """
        if available_percentage is not None:
            pulumi.set(__self__, "available_percentage", available_percentage)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if workload_id is not None:
            pulumi.set(__self__, "workload_id", workload_id)

    @property
    @pulumi.getter(name="availablePercentage")
    def available_percentage(self) -> Optional[pulumi.Input[float]]:
        """
        Workload rule available percentage. Default: `70` (int)
        """
        return pulumi.get(self, "available_percentage")

    @available_percentage.setter
    def available_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "available_percentage", value)

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Workload rule selector (map)
        """
        return pulumi.get(self, "selector")

    @selector.setter
    def selector(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "selector", value)

    @property
    @pulumi.getter(name="workloadId")
    def workload_id(self) -> Optional[pulumi.Input[str]]:
        """
        Workload ID (string)
        """
        return pulumi.get(self, "workload_id")

    @workload_id.setter
    def workload_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "workload_id", value)


@pulumi.input_type
class ProjectContainerResourceLimitArgs:
    def __init__(__self__, *,
                 limits_cpu: Optional[pulumi.Input[str]] = None,
                 limits_memory: Optional[pulumi.Input[str]] = None,
                 requests_cpu: Optional[pulumi.Input[str]] = None,
                 requests_memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] limits_cpu: Limit for limits cpu in project (string)
        :param pulumi.Input[str] limits_memory: Limit for limits memory in project (string)
        :param pulumi.Input[str] requests_cpu: Limit for requests cpu in project (string)
        :param pulumi.Input[str] requests_memory: Limit for requests memory in project (string)
        """
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @limits_cpu.setter
    def limits_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_cpu", value)

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @limits_memory.setter
    def limits_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_memory", value)

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @requests_cpu.setter
    def requests_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_cpu", value)

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @requests_memory.setter
    def requests_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_memory", value)


@pulumi.input_type
class ProjectLoggingCustomTargetConfigArgs:
    def __init__(__self__, *,
                 content: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content: Custom target config content (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        """
        pulumi.set(__self__, "content", content)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)

    @property
    @pulumi.getter
    def content(self) -> pulumi.Input[str]:
        """
        Custom target config content (string)
        """
        return pulumi.get(self, "content")

    @content.setter
    def content(self, value: pulumi.Input[str]):
        pulumi.set(self, "content", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)


@pulumi.input_type
class ProjectLoggingElasticsearchConfigArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 auth_password: Optional[pulumi.Input[str]] = None,
                 auth_username: Optional[pulumi.Input[str]] = None,
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 client_key_pass: Optional[pulumi.Input[str]] = None,
                 date_format: Optional[pulumi.Input[str]] = None,
                 index_prefix: Optional[pulumi.Input[str]] = None,
                 ssl_verify: Optional[pulumi.Input[bool]] = None,
                 ssl_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] auth_password: User password for the elascticsearch service (string)
        :param pulumi.Input[str] auth_username: Username for the elascticsearch service (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[str] client_key_pass: SSL client key password for the splunk service (string)
        :param pulumi.Input[str] date_format: Date format for the elascticsearch logs. Default: `YYYY-MM-DD` (string)
        :param pulumi.Input[str] index_prefix: Index prefix for the elascticsearch logs. Default: `local` (string)
        :param pulumi.Input[bool] ssl_verify: SSL verify for the syslog service (bool)
        :param pulumi.Input[str] ssl_version: SSL version for the elascticsearch service (string)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        if auth_password is not None:
            pulumi.set(__self__, "auth_password", auth_password)
        if auth_username is not None:
            pulumi.set(__self__, "auth_username", auth_username)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if date_format is not None:
            pulumi.set(__self__, "date_format", date_format)
        if index_prefix is not None:
            pulumi.set(__self__, "index_prefix", index_prefix)
        if ssl_verify is not None:
            pulumi.set(__self__, "ssl_verify", ssl_verify)
        if ssl_version is not None:
            pulumi.set(__self__, "ssl_version", ssl_version)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="authPassword")
    def auth_password(self) -> Optional[pulumi.Input[str]]:
        """
        User password for the elascticsearch service (string)
        """
        return pulumi.get(self, "auth_password")

    @auth_password.setter
    def auth_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_password", value)

    @property
    @pulumi.getter(name="authUsername")
    def auth_username(self) -> Optional[pulumi.Input[str]]:
        """
        Username for the elascticsearch service (string)
        """
        return pulumi.get(self, "auth_username")

    @auth_username.setter
    def auth_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_username", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key password for the splunk service (string)
        """
        return pulumi.get(self, "client_key_pass")

    @client_key_pass.setter
    def client_key_pass(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key_pass", value)

    @property
    @pulumi.getter(name="dateFormat")
    def date_format(self) -> Optional[pulumi.Input[str]]:
        """
        Date format for the elascticsearch logs. Default: `YYYY-MM-DD` (string)
        """
        return pulumi.get(self, "date_format")

    @date_format.setter
    def date_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_format", value)

    @property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        Index prefix for the elascticsearch logs. Default: `local` (string)
        """
        return pulumi.get(self, "index_prefix")

    @index_prefix.setter
    def index_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "index_prefix", value)

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        SSL verify for the syslog service (bool)
        """
        return pulumi.get(self, "ssl_verify")

    @ssl_verify.setter
    def ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl_verify", value)

    @property
    @pulumi.getter(name="sslVersion")
    def ssl_version(self) -> Optional[pulumi.Input[str]]:
        """
        SSL version for the elascticsearch service (string)
        """
        return pulumi.get(self, "ssl_version")

    @ssl_version.setter
    def ssl_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssl_version", value)


@pulumi.input_type
class ProjectLoggingFluentdConfigArgs:
    def __init__(__self__, *,
                 fluent_servers: pulumi.Input[List[pulumi.Input['ProjectLoggingFluentdConfigFluentServerArgs']]],
                 certificate: Optional[pulumi.Input[str]] = None,
                 compress: Optional[pulumi.Input[bool]] = None,
                 enable_tls: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[List[pulumi.Input['ProjectLoggingFluentdConfigFluentServerArgs']]] fluent_servers: Servers for the fluentd service (list)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[bool] compress: Compress data for the fluentd service (bool)
        :param pulumi.Input[bool] enable_tls: Enable TLS for the fluentd service (bool)
        """
        pulumi.set(__self__, "fluent_servers", fluent_servers)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)

    @property
    @pulumi.getter(name="fluentServers")
    def fluent_servers(self) -> pulumi.Input[List[pulumi.Input['ProjectLoggingFluentdConfigFluentServerArgs']]]:
        """
        Servers for the fluentd service (list)
        """
        return pulumi.get(self, "fluent_servers")

    @fluent_servers.setter
    def fluent_servers(self, value: pulumi.Input[List[pulumi.Input['ProjectLoggingFluentdConfigFluentServerArgs']]]):
        pulumi.set(self, "fluent_servers", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter
    def compress(self) -> Optional[pulumi.Input[bool]]:
        """
        Compress data for the fluentd service (bool)
        """
        return pulumi.get(self, "compress")

    @compress.setter
    def compress(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "compress", value)

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable TLS for the fluentd service (bool)
        """
        return pulumi.get(self, "enable_tls")

    @enable_tls.setter
    def enable_tls(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_tls", value)


@pulumi.input_type
class ProjectLoggingFluentdConfigFluentServerArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 hostname: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 shared_key: Optional[pulumi.Input[str]] = None,
                 standby: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] hostname: Hostname of the fluentd service (string)
        :param pulumi.Input[str] password: User password of the fluentd service (string)
        :param pulumi.Input[str] shared_key: Shared key of the fluentd service (string)
        :param pulumi.Input[bool] standby: Standby server of the fluentd service (bool)
        :param pulumi.Input[str] username: Username of the fluentd service (string)
        :param pulumi.Input[float] weight: Weight of the fluentd server (int)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if shared_key is not None:
            pulumi.set(__self__, "shared_key", shared_key)
        if standby is not None:
            pulumi.set(__self__, "standby", standby)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[str]]:
        """
        Hostname of the fluentd service (string)
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        User password of the fluentd service (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter(name="sharedKey")
    def shared_key(self) -> Optional[pulumi.Input[str]]:
        """
        Shared key of the fluentd service (string)
        """
        return pulumi.get(self, "shared_key")

    @shared_key.setter
    def shared_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "shared_key", value)

    @property
    @pulumi.getter
    def standby(self) -> Optional[pulumi.Input[bool]]:
        """
        Standby server of the fluentd service (bool)
        """
        return pulumi.get(self, "standby")

    @standby.setter
    def standby(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "standby", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        Username of the fluentd service (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[float]]:
        """
        Weight of the fluentd server (int)
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class ProjectLoggingKafkaConfigArgs:
    def __init__(__self__, *,
                 topic: pulumi.Input[str],
                 broker_endpoints: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 zookeeper_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] topic: Topic to publish on the kafka service (string)
        :param pulumi.Input[List[pulumi.Input[str]]] broker_endpoints: Kafka endpoints for kafka service. Conflicts with `zookeeper_endpoint` (list)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[str] zookeeper_endpoint: Zookeeper endpoint for kafka service. Conflicts with `broker_endpoints` (string)
        """
        pulumi.set(__self__, "topic", topic)
        if broker_endpoints is not None:
            pulumi.set(__self__, "broker_endpoints", broker_endpoints)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if zookeeper_endpoint is not None:
            pulumi.set(__self__, "zookeeper_endpoint", zookeeper_endpoint)

    @property
    @pulumi.getter
    def topic(self) -> pulumi.Input[str]:
        """
        Topic to publish on the kafka service (string)
        """
        return pulumi.get(self, "topic")

    @topic.setter
    def topic(self, value: pulumi.Input[str]):
        pulumi.set(self, "topic", value)

    @property
    @pulumi.getter(name="brokerEndpoints")
    def broker_endpoints(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Kafka endpoints for kafka service. Conflicts with `zookeeper_endpoint` (list)
        """
        return pulumi.get(self, "broker_endpoints")

    @broker_endpoints.setter
    def broker_endpoints(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "broker_endpoints", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="zookeeperEndpoint")
    def zookeeper_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Zookeeper endpoint for kafka service. Conflicts with `broker_endpoints` (string)
        """
        return pulumi.get(self, "zookeeper_endpoint")

    @zookeeper_endpoint.setter
    def zookeeper_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zookeeper_endpoint", value)


@pulumi.input_type
class ProjectLoggingSplunkConfigArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 token: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 client_key_pass: Optional[pulumi.Input[str]] = None,
                 index: Optional[pulumi.Input[str]] = None,
                 source: Optional[pulumi.Input[str]] = None,
                 ssl_verify: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] token: Token for the syslog service (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[str] client_key_pass: SSL client key password for the splunk service (string)
        :param pulumi.Input[str] index: Index prefix for the splunk logs (string)
        :param pulumi.Input[str] source: Date format for the splunk logs (string)
        :param pulumi.Input[bool] ssl_verify: SSL verify for the syslog service (bool)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "token", token)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if index is not None:
            pulumi.set(__self__, "index", index)
        if source is not None:
            pulumi.set(__self__, "source", source)
        if ssl_verify is not None:
            pulumi.set(__self__, "ssl_verify", ssl_verify)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def token(self) -> pulumi.Input[str]:
        """
        Token for the syslog service (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: pulumi.Input[str]):
        pulumi.set(self, "token", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key password for the splunk service (string)
        """
        return pulumi.get(self, "client_key_pass")

    @client_key_pass.setter
    def client_key_pass(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key_pass", value)

    @property
    @pulumi.getter
    def index(self) -> Optional[pulumi.Input[str]]:
        """
        Index prefix for the splunk logs (string)
        """
        return pulumi.get(self, "index")

    @index.setter
    def index(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "index", value)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        """
        Date format for the splunk logs (string)
        """
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        SSL verify for the syslog service (bool)
        """
        return pulumi.get(self, "ssl_verify")

    @ssl_verify.setter
    def ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl_verify", value)


@pulumi.input_type
class ProjectLoggingSyslogConfigArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_cert: Optional[pulumi.Input[str]] = None,
                 client_key: Optional[pulumi.Input[str]] = None,
                 enable_tls: Optional[pulumi.Input[bool]] = None,
                 program: Optional[pulumi.Input[str]] = None,
                 protocol: Optional[pulumi.Input[str]] = None,
                 severity: Optional[pulumi.Input[str]] = None,
                 ssl_verify: Optional[pulumi.Input[bool]] = None,
                 token: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint: Endpoint of the syslog service (string)
        :param pulumi.Input[str] certificate: SSL certificate for the syslog service (string)
        :param pulumi.Input[str] client_cert: SSL client certificate for the syslog service (string)
        :param pulumi.Input[str] client_key: SSL client key for the syslog service (string)
        :param pulumi.Input[bool] enable_tls: Enable TLS for the fluentd service (bool)
        :param pulumi.Input[str] program: Program for the syslog service (string)
        :param pulumi.Input[str] protocol: Protocol for the syslog service. `tcp` and `udp` are supported. Default: `udp` (string)
        :param pulumi.Input[str] severity: Date format for the syslog logs. `emergency`, `alert`, `critical`, `error`, `warning`, `notice`, `info` and `debug` are supported. Default: `notice` (string)
        :param pulumi.Input[bool] ssl_verify: SSL verify for the syslog service (bool)
        :param pulumi.Input[str] token: Token for the syslog service (string)
        """
        pulumi.set(__self__, "endpoint", endpoint)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)
        if program is not None:
            pulumi.set(__self__, "program", program)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if ssl_verify is not None:
            pulumi.set(__self__, "ssl_verify", ssl_verify)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        Endpoint of the syslog service (string)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        SSL certificate for the syslog service (string)
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client certificate for the syslog service (string)
        """
        return pulumi.get(self, "client_cert")

    @client_cert.setter
    def client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cert", value)

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[pulumi.Input[str]]:
        """
        SSL client key for the syslog service (string)
        """
        return pulumi.get(self, "client_key")

    @client_key.setter
    def client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_key", value)

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable TLS for the fluentd service (bool)
        """
        return pulumi.get(self, "enable_tls")

    @enable_tls.setter
    def enable_tls(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_tls", value)

    @property
    @pulumi.getter
    def program(self) -> Optional[pulumi.Input[str]]:
        """
        Program for the syslog service (string)
        """
        return pulumi.get(self, "program")

    @program.setter
    def program(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "program", value)

    @property
    @pulumi.getter
    def protocol(self) -> Optional[pulumi.Input[str]]:
        """
        Protocol for the syslog service. `tcp` and `udp` are supported. Default: `udp` (string)
        """
        return pulumi.get(self, "protocol")

    @protocol.setter
    def protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol", value)

    @property
    @pulumi.getter
    def severity(self) -> Optional[pulumi.Input[str]]:
        """
        Date format for the syslog logs. `emergency`, `alert`, `critical`, `error`, `warning`, `notice`, `info` and `debug` are supported. Default: `notice` (string)
        """
        return pulumi.get(self, "severity")

    @severity.setter
    def severity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "severity", value)

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        SSL verify for the syslog service (bool)
        """
        return pulumi.get(self, "ssl_verify")

    @ssl_verify.setter
    def ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl_verify", value)

    @property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[str]]:
        """
        Token for the syslog service (string)
        """
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token", value)


@pulumi.input_type
class ProjectProjectMonitoringInputArgs:
    def __init__(__self__, *,
                 answers: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] answers: Key/value answers for monitor input (map)
        :param pulumi.Input[str] version: rancher-monitoring chart version (string)
        """
        if answers is not None:
            pulumi.set(__self__, "answers", answers)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def answers(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Key/value answers for monitor input (map)
        """
        return pulumi.get(self, "answers")

    @answers.setter
    def answers(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "answers", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        rancher-monitoring chart version (string)
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class ProjectResourceQuotaArgs:
    def __init__(__self__, *,
                 namespace_default_limit: pulumi.Input['ProjectResourceQuotaNamespaceDefaultLimitArgs'],
                 project_limit: pulumi.Input['ProjectResourceQuotaProjectLimitArgs']):
        """
        :param pulumi.Input['ProjectResourceQuotaNamespaceDefaultLimitArgs'] namespace_default_limit: Default resource quota limit for  namespaces in project (list maxitems:1)
        :param pulumi.Input['ProjectResourceQuotaProjectLimitArgs'] project_limit: Resource quota limit for project (list maxitems:1)
        """
        pulumi.set(__self__, "namespace_default_limit", namespace_default_limit)
        pulumi.set(__self__, "project_limit", project_limit)

    @property
    @pulumi.getter(name="namespaceDefaultLimit")
    def namespace_default_limit(self) -> pulumi.Input['ProjectResourceQuotaNamespaceDefaultLimitArgs']:
        """
        Default resource quota limit for  namespaces in project (list maxitems:1)
        """
        return pulumi.get(self, "namespace_default_limit")

    @namespace_default_limit.setter
    def namespace_default_limit(self, value: pulumi.Input['ProjectResourceQuotaNamespaceDefaultLimitArgs']):
        pulumi.set(self, "namespace_default_limit", value)

    @property
    @pulumi.getter(name="projectLimit")
    def project_limit(self) -> pulumi.Input['ProjectResourceQuotaProjectLimitArgs']:
        """
        Resource quota limit for project (list maxitems:1)
        """
        return pulumi.get(self, "project_limit")

    @project_limit.setter
    def project_limit(self, value: pulumi.Input['ProjectResourceQuotaProjectLimitArgs']):
        pulumi.set(self, "project_limit", value)


@pulumi.input_type
class ProjectResourceQuotaNamespaceDefaultLimitArgs:
    def __init__(__self__, *,
                 config_maps: Optional[pulumi.Input[str]] = None,
                 limits_cpu: Optional[pulumi.Input[str]] = None,
                 limits_memory: Optional[pulumi.Input[str]] = None,
                 persistent_volume_claims: Optional[pulumi.Input[str]] = None,
                 pods: Optional[pulumi.Input[str]] = None,
                 replication_controllers: Optional[pulumi.Input[str]] = None,
                 requests_cpu: Optional[pulumi.Input[str]] = None,
                 requests_memory: Optional[pulumi.Input[str]] = None,
                 requests_storage: Optional[pulumi.Input[str]] = None,
                 secrets: Optional[pulumi.Input[str]] = None,
                 services: Optional[pulumi.Input[str]] = None,
                 services_load_balancers: Optional[pulumi.Input[str]] = None,
                 services_node_ports: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] config_maps: Limit for config maps in project (string)
        :param pulumi.Input[str] limits_cpu: Limit for limits cpu in project (string)
        :param pulumi.Input[str] limits_memory: Limit for limits memory in project (string)
        :param pulumi.Input[str] persistent_volume_claims: Limit for persistent volume claims in project (string)
        :param pulumi.Input[str] pods: Limit for pods in project (string)
        :param pulumi.Input[str] replication_controllers: Limit for replication controllers in project (string)
        :param pulumi.Input[str] requests_cpu: Limit for requests cpu in project (string)
        :param pulumi.Input[str] requests_memory: Limit for requests memory in project (string)
        :param pulumi.Input[str] requests_storage: Limit for requests storage in project (string)
        :param pulumi.Input[str] secrets: Limit for secrets in project (string)
        :param pulumi.Input[str] services_load_balancers: Limit for services load balancers in project (string)
        :param pulumi.Input[str] services_node_ports: Limit for services node ports in project (string)
        """
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for config maps in project (string)
        """
        return pulumi.get(self, "config_maps")

    @config_maps.setter
    def config_maps(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config_maps", value)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @limits_cpu.setter
    def limits_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_cpu", value)

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @limits_memory.setter
    def limits_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_memory", value)

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for persistent volume claims in project (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @persistent_volume_claims.setter
    def persistent_volume_claims(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "persistent_volume_claims", value)

    @property
    @pulumi.getter
    def pods(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for pods in project (string)
        """
        return pulumi.get(self, "pods")

    @pods.setter
    def pods(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pods", value)

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for replication controllers in project (string)
        """
        return pulumi.get(self, "replication_controllers")

    @replication_controllers.setter
    def replication_controllers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "replication_controllers", value)

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @requests_cpu.setter
    def requests_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_cpu", value)

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @requests_memory.setter
    def requests_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_memory", value)

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests storage in project (string)
        """
        return pulumi.get(self, "requests_storage")

    @requests_storage.setter
    def requests_storage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_storage", value)

    @property
    @pulumi.getter
    def secrets(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for secrets in project (string)
        """
        return pulumi.get(self, "secrets")

    @secrets.setter
    def secrets(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secrets", value)

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "services")

    @services.setter
    def services(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services", value)

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for services load balancers in project (string)
        """
        return pulumi.get(self, "services_load_balancers")

    @services_load_balancers.setter
    def services_load_balancers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_load_balancers", value)

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for services node ports in project (string)
        """
        return pulumi.get(self, "services_node_ports")

    @services_node_ports.setter
    def services_node_ports(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_node_ports", value)


@pulumi.input_type
class ProjectResourceQuotaProjectLimitArgs:
    def __init__(__self__, *,
                 config_maps: Optional[pulumi.Input[str]] = None,
                 limits_cpu: Optional[pulumi.Input[str]] = None,
                 limits_memory: Optional[pulumi.Input[str]] = None,
                 persistent_volume_claims: Optional[pulumi.Input[str]] = None,
                 pods: Optional[pulumi.Input[str]] = None,
                 replication_controllers: Optional[pulumi.Input[str]] = None,
                 requests_cpu: Optional[pulumi.Input[str]] = None,
                 requests_memory: Optional[pulumi.Input[str]] = None,
                 requests_storage: Optional[pulumi.Input[str]] = None,
                 secrets: Optional[pulumi.Input[str]] = None,
                 services: Optional[pulumi.Input[str]] = None,
                 services_load_balancers: Optional[pulumi.Input[str]] = None,
                 services_node_ports: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] config_maps: Limit for config maps in project (string)
        :param pulumi.Input[str] limits_cpu: Limit for limits cpu in project (string)
        :param pulumi.Input[str] limits_memory: Limit for limits memory in project (string)
        :param pulumi.Input[str] persistent_volume_claims: Limit for persistent volume claims in project (string)
        :param pulumi.Input[str] pods: Limit for pods in project (string)
        :param pulumi.Input[str] replication_controllers: Limit for replication controllers in project (string)
        :param pulumi.Input[str] requests_cpu: Limit for requests cpu in project (string)
        :param pulumi.Input[str] requests_memory: Limit for requests memory in project (string)
        :param pulumi.Input[str] requests_storage: Limit for requests storage in project (string)
        :param pulumi.Input[str] secrets: Limit for secrets in project (string)
        :param pulumi.Input[str] services_load_balancers: Limit for services load balancers in project (string)
        :param pulumi.Input[str] services_node_ports: Limit for services node ports in project (string)
        """
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for config maps in project (string)
        """
        return pulumi.get(self, "config_maps")

    @config_maps.setter
    def config_maps(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config_maps", value)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @limits_cpu.setter
    def limits_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_cpu", value)

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @limits_memory.setter
    def limits_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "limits_memory", value)

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for persistent volume claims in project (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @persistent_volume_claims.setter
    def persistent_volume_claims(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "persistent_volume_claims", value)

    @property
    @pulumi.getter
    def pods(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for pods in project (string)
        """
        return pulumi.get(self, "pods")

    @pods.setter
    def pods(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pods", value)

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for replication controllers in project (string)
        """
        return pulumi.get(self, "replication_controllers")

    @replication_controllers.setter
    def replication_controllers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "replication_controllers", value)

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @requests_cpu.setter
    def requests_cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_cpu", value)

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @requests_memory.setter
    def requests_memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_memory", value)

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for requests storage in project (string)
        """
        return pulumi.get(self, "requests_storage")

    @requests_storage.setter
    def requests_storage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "requests_storage", value)

    @property
    @pulumi.getter
    def secrets(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for secrets in project (string)
        """
        return pulumi.get(self, "secrets")

    @secrets.setter
    def secrets(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secrets", value)

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "services")

    @services.setter
    def services(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services", value)

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for services load balancers in project (string)
        """
        return pulumi.get(self, "services_load_balancers")

    @services_load_balancers.setter
    def services_load_balancers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_load_balancers", value)

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[pulumi.Input[str]]:
        """
        Limit for services node ports in project (string)
        """
        return pulumi.get(self, "services_node_ports")

    @services_node_ports.setter
    def services_node_ports(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_node_ports", value)


@pulumi.input_type
class RegistryRegistryArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 password: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] address: Address for registry.
        :param pulumi.Input[str] password: Password for the registry (string)
        :param pulumi.Input[str] username: Username for the registry (string)
        """
        pulumi.set(__self__, "address", address)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        """
        Address for registry.
        """
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        Password for the registry (string)
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        Username for the registry (string)
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class RoleTempalteRuleArgs:
    def __init__(__self__, *,
                 api_groups: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 non_resource_urls: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 resource_names: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 resources: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None,
                 verbs: Optional[pulumi.Input[List[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[List[pulumi.Input[str]]] api_groups: Policy rule api groups (list)
        :param pulumi.Input[List[pulumi.Input[str]]] non_resource_urls: Policy rule non resource urls (list)
        :param pulumi.Input[List[pulumi.Input[str]]] resource_names: Policy rule resource names (list)
        :param pulumi.Input[List[pulumi.Input[str]]] resources: Policy rule resources (list)
        :param pulumi.Input[List[pulumi.Input[str]]] verbs: Policy rule verbs. `create`, `delete`, `get`, `list`, `patch`, `update`, `view`, `watch` and `*` values are supported (list)
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Policy rule api groups (list)
        """
        return pulumi.get(self, "api_groups")

    @api_groups.setter
    def api_groups(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "api_groups", value)

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Policy rule non resource urls (list)
        """
        return pulumi.get(self, "non_resource_urls")

    @non_resource_urls.setter
    def non_resource_urls(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "non_resource_urls", value)

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Policy rule resource names (list)
        """
        return pulumi.get(self, "resource_names")

    @resource_names.setter
    def resource_names(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "resource_names", value)

    @property
    @pulumi.getter
    def resources(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Policy rule resources (list)
        """
        return pulumi.get(self, "resources")

    @resources.setter
    def resources(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "resources", value)

    @property
    @pulumi.getter
    def verbs(self) -> Optional[pulumi.Input[List[pulumi.Input[str]]]]:
        """
        Policy rule verbs. `create`, `delete`, `get`, `list`, `patch`, `update`, `view`, `watch` and `*` values are supported (list)
        """
        return pulumi.get(self, "verbs")

    @verbs.setter
    def verbs(self, value: Optional[pulumi.Input[List[pulumi.Input[str]]]]):
        pulumi.set(self, "verbs", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateAllowedCsiDriverArgs:
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: The name of the PodSecurityPolicyTemplate (string)
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the PodSecurityPolicyTemplate (string)
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateAllowedFlexVolumeArgs:
    def __init__(__self__, *,
                 driver: str):
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> str:
        return pulumi.get(self, "driver")

    @driver.setter
    def driver(self, value: str):
        pulumi.set(self, "driver", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateAllowedHostPathArgs:
    def __init__(__self__, *,
                 path_prefix: str,
                 read_only: Optional[bool] = None):
        pulumi.set(__self__, "path_prefix", path_prefix)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="pathPrefix")
    def path_prefix(self) -> str:
        return pulumi.get(self, "path_prefix")

    @path_prefix.setter
    def path_prefix(self, value: str):
        pulumi.set(self, "path_prefix", value)

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[bool]:
        return pulumi.get(self, "read_only")

    @read_only.setter
    def read_only(self, value: Optional[bool]):
        pulumi.set(self, "read_only", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateFsGroupArgs:
    def __init__(__self__, *,
                 ranges: List['GetPodSecurityPolicyTemplateFsGroupRangeArgs'],
                 rule: Optional[str] = None):
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> List['GetPodSecurityPolicyTemplateFsGroupRangeArgs']:
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: List['GetPodSecurityPolicyTemplateFsGroupRangeArgs']):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: Optional[str]):
        pulumi.set(self, "rule", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateFsGroupRangeArgs:
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: float):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: float):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateHostPortArgs:
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: float):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: float):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsGroupArgs:
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[List['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs']] = None):
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: str):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs']]:
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[List['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs']]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsGroupRangeArgs:
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: float):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: float):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsUserArgs:
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[List['GetPodSecurityPolicyTemplateRunAsUserRangeArgs']] = None):
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: str):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['GetPodSecurityPolicyTemplateRunAsUserRangeArgs']]:
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[List['GetPodSecurityPolicyTemplateRunAsUserRangeArgs']]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsUserRangeArgs:
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: float):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: float):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRuntimeClassArgs:
    def __init__(__self__, *,
                 allowed_runtime_class_names: List[str],
                 default_runtime_class_name: Optional[str] = None):
        pulumi.set(__self__, "allowed_runtime_class_names", allowed_runtime_class_names)
        if default_runtime_class_name is not None:
            pulumi.set(__self__, "default_runtime_class_name", default_runtime_class_name)

    @property
    @pulumi.getter(name="allowedRuntimeClassNames")
    def allowed_runtime_class_names(self) -> List[str]:
        return pulumi.get(self, "allowed_runtime_class_names")

    @allowed_runtime_class_names.setter
    def allowed_runtime_class_names(self, value: List[str]):
        pulumi.set(self, "allowed_runtime_class_names", value)

    @property
    @pulumi.getter(name="defaultRuntimeClassName")
    def default_runtime_class_name(self) -> Optional[str]:
        return pulumi.get(self, "default_runtime_class_name")

    @default_runtime_class_name.setter
    def default_runtime_class_name(self, value: Optional[str]):
        pulumi.set(self, "default_runtime_class_name", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateSeLinuxArgs:
    def __init__(__self__, *,
                 rule: str,
                 se_linux_option: Optional['GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs'] = None):
        pulumi.set(__self__, "rule", rule)
        if se_linux_option is not None:
            pulumi.set(__self__, "se_linux_option", se_linux_option)

    @property
    @pulumi.getter
    def rule(self) -> str:
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: str):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter(name="seLinuxOption")
    def se_linux_option(self) -> Optional['GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs']:
        return pulumi.get(self, "se_linux_option")

    @se_linux_option.setter
    def se_linux_option(self, value: Optional['GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs']):
        pulumi.set(self, "se_linux_option", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs:
    def __init__(__self__, *,
                 level: Optional[str] = None,
                 role: Optional[str] = None,
                 type: Optional[str] = None,
                 user: Optional[str] = None):
        if level is not None:
            pulumi.set(__self__, "level", level)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def level(self) -> Optional[str]:
        return pulumi.get(self, "level")

    @level.setter
    def level(self, value: Optional[str]):
        pulumi.set(self, "level", value)

    @property
    @pulumi.getter
    def role(self) -> Optional[str]:
        return pulumi.get(self, "role")

    @role.setter
    def role(self, value: Optional[str]):
        pulumi.set(self, "role", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[str]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateSupplementalGroupArgs:
    def __init__(__self__, *,
                 ranges: List['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs'],
                 rule: Optional[str] = None):
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> List['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs']:
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: List['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs']):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: Optional[str]):
        pulumi.set(self, "rule", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs:
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: float):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: float):
        pulumi.set(self, "min", value)


