# 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 copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities

__all__ = [
    'CloudCredentialAmazonec2CredentialConfigArgs',
    'CloudCredentialAzureCredentialConfigArgs',
    'CloudCredentialDigitaloceanCredentialConfigArgs',
    'CloudCredentialGoogleCredentialConfigArgs',
    'CloudCredentialHarvesterCredentialConfigArgs',
    'CloudCredentialLinodeCredentialConfigArgs',
    'CloudCredentialOpenstackCredentialConfigArgs',
    'CloudCredentialS3CredentialConfigArgs',
    'CloudCredentialVsphereCredentialConfigArgs',
    'ClusterAgentEnvVarArgs',
    'ClusterAksConfigArgs',
    'ClusterAksConfigV2Args',
    'ClusterAksConfigV2NodePoolArgs',
    'ClusterAlertGroupRecipientArgs',
    'ClusterAlertRuleEventRuleArgs',
    'ClusterAlertRuleMetricRuleArgs',
    'ClusterAlertRuleNodeRuleArgs',
    'ClusterAlertRuleSystemServiceRuleArgs',
    'ClusterClusterAgentDeploymentCustomizationArgs',
    'ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs',
    'ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs',
    'ClusterClusterAuthEndpointArgs',
    'ClusterClusterMonitoringInputArgs',
    'ClusterClusterRegistrationTokenArgs',
    'ClusterClusterTemplateAnswersArgs',
    'ClusterClusterTemplateQuestionArgs',
    'ClusterEksConfigArgs',
    'ClusterEksConfigV2Args',
    'ClusterEksConfigV2NodeGroupArgs',
    'ClusterEksConfigV2NodeGroupLaunchTemplateArgs',
    'ClusterFleetAgentDeploymentCustomizationArgs',
    'ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs',
    'ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirementArgs',
    'ClusterGkeConfigArgs',
    'ClusterGkeConfigV2Args',
    'ClusterGkeConfigV2ClusterAddonsArgs',
    'ClusterGkeConfigV2IpAllocationPolicyArgs',
    'ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs',
    'ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs',
    'ClusterGkeConfigV2NodePoolArgs',
    'ClusterGkeConfigV2NodePoolAutoscalingArgs',
    'ClusterGkeConfigV2NodePoolConfigArgs',
    'ClusterGkeConfigV2NodePoolConfigTaintArgs',
    'ClusterGkeConfigV2NodePoolManagementArgs',
    'ClusterGkeConfigV2PrivateClusterConfigArgs',
    'ClusterK3sConfigArgs',
    'ClusterK3sConfigUpgradeStrategyArgs',
    'ClusterOkeConfigArgs',
    'ClusterRke2ConfigArgs',
    'ClusterRke2ConfigUpgradeStrategyArgs',
    'ClusterRkeConfigArgs',
    'ClusterRkeConfigAuthenticationArgs',
    'ClusterRkeConfigAuthorizationArgs',
    'ClusterRkeConfigBastionHostArgs',
    'ClusterRkeConfigCloudProviderArgs',
    'ClusterRkeConfigCloudProviderAwsCloudProviderArgs',
    'ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs',
    'ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs',
    'ClusterRkeConfigCloudProviderAzureCloudProviderArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs',
    'ClusterRkeConfigDnsArgs',
    'ClusterRkeConfigDnsLinearAutoscalerParamsArgs',
    'ClusterRkeConfigDnsNodelocalArgs',
    'ClusterRkeConfigDnsTolerationArgs',
    'ClusterRkeConfigDnsUpdateStrategyArgs',
    'ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs',
    'ClusterRkeConfigIngressArgs',
    'ClusterRkeConfigIngressTolerationArgs',
    'ClusterRkeConfigIngressUpdateStrategyArgs',
    'ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs',
    'ClusterRkeConfigMonitoringArgs',
    'ClusterRkeConfigMonitoringTolerationArgs',
    'ClusterRkeConfigMonitoringUpdateStrategyArgs',
    'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs',
    'ClusterRkeConfigNetworkArgs',
    'ClusterRkeConfigNetworkAciNetworkProviderArgs',
    'ClusterRkeConfigNetworkCalicoNetworkProviderArgs',
    'ClusterRkeConfigNetworkCanalNetworkProviderArgs',
    'ClusterRkeConfigNetworkFlannelNetworkProviderArgs',
    'ClusterRkeConfigNetworkTolerationArgs',
    'ClusterRkeConfigNetworkWeaveNetworkProviderArgs',
    'ClusterRkeConfigNodeArgs',
    'ClusterRkeConfigPrivateRegistryArgs',
    'ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs',
    'ClusterRkeConfigServicesArgs',
    'ClusterRkeConfigServicesEtcdArgs',
    'ClusterRkeConfigServicesEtcdBackupConfigArgs',
    'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs',
    'ClusterRkeConfigServicesKubeApiArgs',
    'ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs',
    'ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs',
    'ClusterRkeConfigServicesKubeApiAuditLogArgs',
    'ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs',
    'ClusterRkeConfigServicesKubeApiEventRateLimitArgs',
    'ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs',
    'ClusterRkeConfigServicesKubeControllerArgs',
    'ClusterRkeConfigServicesKubeletArgs',
    'ClusterRkeConfigServicesKubeproxyArgs',
    'ClusterRkeConfigServicesSchedulerArgs',
    'ClusterRkeConfigUpgradeStrategyArgs',
    'ClusterRkeConfigUpgradeStrategyDrainInputArgs',
    'ClusterSyncNodeArgs',
    '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',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputArgs',
    'ClusterTemplateTemplateRevisionQuestionArgs',
    'ClusterV2AgentEnvVarArgs',
    'ClusterV2ClusterAgentDeploymentCustomizationArgs',
    'ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs',
    'ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs',
    'ClusterV2ClusterRegistrationTokenArgs',
    'ClusterV2FleetAgentDeploymentCustomizationArgs',
    'ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs',
    'ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs',
    'ClusterV2LocalAuthEndpointArgs',
    'ClusterV2RkeConfigArgs',
    'ClusterV2RkeConfigEtcdArgs',
    'ClusterV2RkeConfigEtcdS3ConfigArgs',
    'ClusterV2RkeConfigEtcdSnapshotCreateArgs',
    'ClusterV2RkeConfigEtcdSnapshotRestoreArgs',
    'ClusterV2RkeConfigLocalAuthEndpointArgs',
    'ClusterV2RkeConfigMachinePoolArgs',
    'ClusterV2RkeConfigMachinePoolDefaultArgs',
    'ClusterV2RkeConfigMachinePoolMachineConfigArgs',
    'ClusterV2RkeConfigMachinePoolRollingUpdateArgs',
    'ClusterV2RkeConfigMachinePoolTaintArgs',
    'ClusterV2RkeConfigMachineSelectorConfigArgs',
    'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs',
    'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs',
    'ClusterV2RkeConfigMachineSelectorFileArgs',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceArgs',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs',
    'ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs',
    'ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs',
    'ClusterV2RkeConfigRegistriesArgs',
    'ClusterV2RkeConfigRegistriesConfigArgs',
    'ClusterV2RkeConfigRegistriesMirrorArgs',
    'ClusterV2RkeConfigRotateCertificatesArgs',
    'ClusterV2RkeConfigUpgradeStrategyArgs',
    'ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs',
    'ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs',
    'EtcdBackupBackupConfigArgs',
    'EtcdBackupBackupConfigS3BackupConfigArgs',
    'GlobalDnsProviderAlidnsConfigArgs',
    'GlobalDnsProviderCloudflareConfigArgs',
    'GlobalDnsProviderRoute53ConfigArgs',
    'GlobalRoleRuleArgs',
    'MachineConfigV2Amazonec2ConfigArgs',
    'MachineConfigV2AzureConfigArgs',
    'MachineConfigV2DigitaloceanConfigArgs',
    'MachineConfigV2HarvesterConfigArgs',
    'MachineConfigV2LinodeConfigArgs',
    'MachineConfigV2OpenstackConfigArgs',
    'MachineConfigV2VsphereConfigArgs',
    'MultiClusterAppAnswerArgs',
    'MultiClusterAppMemberArgs',
    'MultiClusterAppTargetArgs',
    'MultiClusterAppUpgradeStrategyArgs',
    'MultiClusterAppUpgradeStrategyRollingUpdateArgs',
    'NamespaceContainerResourceLimitArgs',
    'NamespaceResourceQuotaArgs',
    'NamespaceResourceQuotaLimitArgs',
    'NodePoolNodeTaintArgs',
    'NodeTemplateAmazonec2ConfigArgs',
    'NodeTemplateAzureConfigArgs',
    'NodeTemplateDigitaloceanConfigArgs',
    'NodeTemplateHarvesterConfigArgs',
    'NodeTemplateHetznerConfigArgs',
    'NodeTemplateLinodeConfigArgs',
    'NodeTemplateNodeTaintArgs',
    'NodeTemplateOpennebulaConfigArgs',
    'NodeTemplateOpenstackConfigArgs',
    'NodeTemplateOutscaleConfigArgs',
    'NodeTemplateVsphereConfigArgs',
    'NotifierDingtalkConfigArgs',
    'NotifierMsteamsConfigArgs',
    'NotifierPagerdutyConfigArgs',
    'NotifierSlackConfigArgs',
    'NotifierSmtpConfigArgs',
    'NotifierWebhookConfigArgs',
    'NotifierWechatConfigArgs',
    'PodSecurityAdmissionConfigurationTemplateDefaultsArgs',
    'PodSecurityAdmissionConfigurationTemplateExemptionsArgs',
    'PodSecurityPolicyTemplateAllowedCsiDriverArgs',
    'PodSecurityPolicyTemplateAllowedFlexVolumeArgs',
    'PodSecurityPolicyTemplateAllowedHostPathArgs',
    'PodSecurityPolicyTemplateFsGroupArgs',
    'PodSecurityPolicyTemplateFsGroupRangeArgs',
    'PodSecurityPolicyTemplateHostPortArgs',
    'PodSecurityPolicyTemplateRunAsGroupArgs',
    'PodSecurityPolicyTemplateRunAsGroupRangeArgs',
    'PodSecurityPolicyTemplateRunAsUserArgs',
    'PodSecurityPolicyTemplateRunAsUserRangeArgs',
    'PodSecurityPolicyTemplateRuntimeClassArgs',
    'PodSecurityPolicyTemplateSeLinuxArgs',
    'PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs',
    'PodSecurityPolicyTemplateSupplementalGroupArgs',
    'PodSecurityPolicyTemplateSupplementalGroupRangeArgs',
    'ProjectAlertGroupRecipientArgs',
    'ProjectAlertRuleMetricRuleArgs',
    'ProjectAlertRulePodRuleArgs',
    'ProjectAlertRuleWorkloadRuleArgs',
    'ProjectContainerResourceLimitArgs',
    'ProjectProjectMonitoringInputArgs',
    'ProjectResourceQuotaArgs',
    'ProjectResourceQuotaNamespaceDefaultLimitArgs',
    'ProjectResourceQuotaProjectLimitArgs',
    'RegistryRegistryArgs',
    'RoleTemplateRuleArgs',
    'GetNotifierDingtalkConfigArgs',
    'GetNotifierMsteamsConfigArgs',
    '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],
                 default_region: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_key: AWS Access Key
        :param pulumi.Input[str] secret_key: AWS Secret Key
        :param pulumi.Input[str] default_region: AWS default region
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if default_region is not None:
            pulumi.set(__self__, "default_region", default_region)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        AWS Access Key
        """
        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
        """
        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(name="defaultRegion")
    def default_region(self) -> Optional[pulumi.Input[str]]:
        """
        AWS default region
        """
        return pulumi.get(self, "default_region")

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


@pulumi.input_type
class CloudCredentialAzureCredentialConfigArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 subscription_id: pulumi.Input[str],
                 environment: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] client_id: Azure Service Principal Account ID
        :param pulumi.Input[str] client_secret: Azure Service Principal Account password
        :param pulumi.Input[str] subscription_id: Azure Subscription ID
        :param pulumi.Input[str] environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param pulumi.Input[str] tenant_id: Azure Tenant ID
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[str]:
        """
        Azure Service Principal Account ID
        """
        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
        """
        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
        """
        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
    def environment(self) -> Optional[pulumi.Input[str]]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        """
        return pulumi.get(self, "environment")

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

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

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


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

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> pulumi.Input[str]:
        """
        Digital Ocean access token
        """
        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 CloudCredentialGoogleCredentialConfigArgs:
    def __init__(__self__, *,
                 auth_encoded_json: pulumi.Input[str]):
        """
        :param pulumi.Input[str] auth_encoded_json: Google auth encoded json
        """
        pulumi.set(__self__, "auth_encoded_json", auth_encoded_json)

    @property
    @pulumi.getter(name="authEncodedJson")
    def auth_encoded_json(self) -> pulumi.Input[str]:
        """
        Google auth encoded json
        """
        return pulumi.get(self, "auth_encoded_json")

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


@pulumi.input_type
class CloudCredentialHarvesterCredentialConfigArgs:
    def __init__(__self__, *,
                 cluster_type: pulumi.Input[str],
                 kubeconfig_content: pulumi.Input[str],
                 cluster_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cluster_type: Harvester cluster type. must be imported or external
        :param pulumi.Input[str] kubeconfig_content: Harvester cluster kubeconfig content
        :param pulumi.Input[str] cluster_id: The cluster id of imported Harvester cluster
        """
        pulumi.set(__self__, "cluster_type", cluster_type)
        pulumi.set(__self__, "kubeconfig_content", kubeconfig_content)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)

    @property
    @pulumi.getter(name="clusterType")
    def cluster_type(self) -> pulumi.Input[str]:
        """
        Harvester cluster type. must be imported or external
        """
        return pulumi.get(self, "cluster_type")

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

    @property
    @pulumi.getter(name="kubeconfigContent")
    def kubeconfig_content(self) -> pulumi.Input[str]:
        """
        Harvester cluster kubeconfig content
        """
        return pulumi.get(self, "kubeconfig_content")

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

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        The cluster id of imported Harvester cluster
        """
        return pulumi.get(self, "cluster_id")

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


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

    @property
    @pulumi.getter
    def token(self) -> pulumi.Input[str]:
        """
        Linode API token
        """
        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: OpenStack password
        """
        pulumi.set(__self__, "password", password)

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

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


@pulumi.input_type
class CloudCredentialS3CredentialConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 secret_key: pulumi.Input[str],
                 default_bucket: Optional[pulumi.Input[str]] = None,
                 default_endpoint: Optional[pulumi.Input[str]] = None,
                 default_endpoint_ca: Optional[pulumi.Input[str]] = None,
                 default_folder: Optional[pulumi.Input[str]] = None,
                 default_region: Optional[pulumi.Input[str]] = None,
                 default_skip_ssl_verify: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] access_key: AWS Access Key
        :param pulumi.Input[str] secret_key: AWS Secret Key
        :param pulumi.Input[str] default_bucket: AWS default bucket
        :param pulumi.Input[str] default_endpoint: AWS default endpoint
        :param pulumi.Input[str] default_endpoint_ca: AWS default endpoint CA
        :param pulumi.Input[str] default_folder: AWS default folder
        :param pulumi.Input[str] default_region: AWS default region
        :param pulumi.Input[bool] default_skip_ssl_verify: AWS default skip ssl verify
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if default_bucket is not None:
            pulumi.set(__self__, "default_bucket", default_bucket)
        if default_endpoint is not None:
            pulumi.set(__self__, "default_endpoint", default_endpoint)
        if default_endpoint_ca is not None:
            pulumi.set(__self__, "default_endpoint_ca", default_endpoint_ca)
        if default_folder is not None:
            pulumi.set(__self__, "default_folder", default_folder)
        if default_region is not None:
            pulumi.set(__self__, "default_region", default_region)
        if default_skip_ssl_verify is not None:
            pulumi.set(__self__, "default_skip_ssl_verify", default_skip_ssl_verify)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        AWS Access Key
        """
        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
        """
        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(name="defaultBucket")
    def default_bucket(self) -> Optional[pulumi.Input[str]]:
        """
        AWS default bucket
        """
        return pulumi.get(self, "default_bucket")

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

    @property
    @pulumi.getter(name="defaultEndpoint")
    def default_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        AWS default endpoint
        """
        return pulumi.get(self, "default_endpoint")

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

    @property
    @pulumi.getter(name="defaultEndpointCa")
    def default_endpoint_ca(self) -> Optional[pulumi.Input[str]]:
        """
        AWS default endpoint CA
        """
        return pulumi.get(self, "default_endpoint_ca")

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

    @property
    @pulumi.getter(name="defaultFolder")
    def default_folder(self) -> Optional[pulumi.Input[str]]:
        """
        AWS default folder
        """
        return pulumi.get(self, "default_folder")

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

    @property
    @pulumi.getter(name="defaultRegion")
    def default_region(self) -> Optional[pulumi.Input[str]]:
        """
        AWS default region
        """
        return pulumi.get(self, "default_region")

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

    @property
    @pulumi.getter(name="defaultSkipSslVerify")
    def default_skip_ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        AWS default skip ssl verify
        """
        return pulumi.get(self, "default_skip_ssl_verify")

    @default_skip_ssl_verify.setter
    def default_skip_ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "default_skip_ssl_verify", 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
        :param pulumi.Input[str] username: vSphere username
        :param pulumi.Input[str] vcenter: vSphere IP/hostname for vCenter
        :param pulumi.Input[str] vcenter_port: vSphere Port for vCenter
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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 ClusterAgentEnvVarArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", 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[int]] = 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[int]] = 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,
                 load_balancer_sku: Optional[pulumi.Input[str]] = 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[int]] = 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,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] agent_dns_prefix: DNS prefix to be used to create the FQDN for the agent pool
        :param pulumi.Input[str] client_id: Azure client ID to use
        :param pulumi.Input[str] client_secret: Azure client secret associated with the "client id"
        :param pulumi.Input[str] kubernetes_version: Specify the version of Kubernetes
        :param pulumi.Input[str] master_dns_prefix: DNS prefix to use the Kubernetes cluster control pane
        :param pulumi.Input[str] resource_group: The name of the Cluster resource group
        :param pulumi.Input[str] ssh_public_key_contents: Contents of the SSH public key used to authenticate with Linux hosts
        :param pulumi.Input[str] subnet: The name of an existing Azure Virtual Subnet. Composite of agent virtual network subnet ID
        :param pulumi.Input[str] subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription
        :param pulumi.Input[str] tenant_id: Azure tenant ID to use
        :param pulumi.Input[str] virtual_network: The name of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        :param pulumi.Input[str] virtual_network_resource_group: The resource group of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        :param pulumi.Input[str] aad_server_app_secret: The secret of an Azure Active Directory server application
        :param pulumi.Input[str] aad_tenant_id: The ID of an Azure Active Directory tenant
        :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
        :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)
        :param pulumi.Input[str] admin_username: The administrator username to use for Linux hosts
        :param pulumi.Input[int] 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
        :param pulumi.Input[str] agent_pool_name: Name for the agent pool, upto 12 alphanumeric characters
        :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]
        :param pulumi.Input[str] agent_vm_size: Size of machine in the agent pool
        :param pulumi.Input[str] auth_base_url: Different authentication API url to use
        :param pulumi.Input[str] base_url: Different resource management API url to use
        :param pulumi.Input[int] count: Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive)
        :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"
        :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"
        :param pulumi.Input[bool] enable_http_application_routing: Enable the Kubernetes ingress with automatic public DNS name creation
        :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"
        :param pulumi.Input[str] load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        :param pulumi.Input[str] location: Azure Kubernetes cluster location
        :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}'
        :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
        :param pulumi.Input[int] max_pods: Maximum number of pods that can run on a node
        :param pulumi.Input[str] network_plugin: Network plugin used for building Kubernetes network. Chooses from [azure kubenet]
        :param pulumi.Input[str] network_policy: Network policy used for building Kubernetes network. Chooses from [calico]
        :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".
        :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
        :param pulumi.Input[Mapping[str, Any]] tag: Tags for Kubernetes cluster. For example, foo=bar
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags for Kubernetes cluster. For example, `["foo=bar","bar=foo"]`
        """
        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 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 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:
            warnings.warn("""Use tags argument instead as []string""", DeprecationWarning)
            pulumi.log.warn("""tag is deprecated: Use tags argument instead as []string""")
        if tag is not None:
            pulumi.set(__self__, "tag", tag)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @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
        """
        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
        """
        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"
        """
        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]:
        """
        Specify the version of Kubernetes
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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 an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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)
        """
        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
        """
        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[int]]:
        """
        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
        """
        return pulumi.get(self, "agent_os_disk_size")

    @agent_os_disk_size.setter
    def agent_os_disk_size(self, value: Optional[pulumi.Input[int]]):
        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
        """
        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]
        """
        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
        """
        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
        """
        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
        """
        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[int]]:
        """
        Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive)
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: Optional[pulumi.Input[int]]):
        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"
        """
        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"
        """
        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
        """
        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"
        """
        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(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[pulumi.Input[str]]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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
        """
        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}'
        """
        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
        """
        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[int]]:
        """
        Maximum number of pods that can run on a node
        """
        return pulumi.get(self, "max_pods")

    @max_pods.setter
    def max_pods(self, value: Optional[pulumi.Input[int]]):
        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 kubenet]
        """
        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]
        """
        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".
        """
        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
        """
        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
        """
        warnings.warn("""Use tags argument instead as []string""", DeprecationWarning)
        pulumi.log.warn("""tag is deprecated: Use tags argument instead as []string""")

        return pulumi.get(self, "tag")

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

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

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


@pulumi.input_type
class ClusterAksConfigV2Args:
    def __init__(__self__, *,
                 cloud_credential_id: pulumi.Input[str],
                 resource_group: pulumi.Input[str],
                 resource_location: pulumi.Input[str],
                 auth_base_url: Optional[pulumi.Input[str]] = None,
                 authorized_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 base_url: Optional[pulumi.Input[str]] = None,
                 dns_prefix: Optional[pulumi.Input[str]] = None,
                 http_application_routing: Optional[pulumi.Input[bool]] = None,
                 imported: Optional[pulumi.Input[bool]] = None,
                 kubernetes_version: Optional[pulumi.Input[str]] = None,
                 linux_admin_username: Optional[pulumi.Input[str]] = None,
                 linux_ssh_public_key: Optional[pulumi.Input[str]] = None,
                 load_balancer_sku: Optional[pulumi.Input[str]] = None,
                 log_analytics_workspace_group: Optional[pulumi.Input[str]] = None,
                 log_analytics_workspace_name: Optional[pulumi.Input[str]] = None,
                 monitoring: Optional[pulumi.Input[bool]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network_dns_service_ip: Optional[pulumi.Input[str]] = None,
                 network_docker_bridge_cidr: Optional[pulumi.Input[str]] = None,
                 network_plugin: Optional[pulumi.Input[str]] = None,
                 network_pod_cidr: Optional[pulumi.Input[str]] = None,
                 network_policy: Optional[pulumi.Input[str]] = None,
                 network_service_cidr: Optional[pulumi.Input[str]] = None,
                 node_pools: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterAksConfigV2NodePoolArgs']]]] = None,
                 private_cluster: Optional[pulumi.Input[bool]] = None,
                 subnet: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 virtual_network: Optional[pulumi.Input[str]] = None,
                 virtual_network_resource_group: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cloud_credential_id: The AKS Cloud Credential ID to use
        :param pulumi.Input[str] resource_group: The AKS resource group
        :param pulumi.Input[str] resource_location: The AKS resource location
        :param pulumi.Input[str] auth_base_url: The AKS auth base url
        :param pulumi.Input[Sequence[pulumi.Input[str]]] authorized_ip_ranges: The AKS authorized ip ranges
        :param pulumi.Input[str] base_url: The AKS base url
        :param pulumi.Input[str] dns_prefix: The AKS dns prefix. Required if `import=false`
        :param pulumi.Input[bool] http_application_routing: Enable AKS http application routing?
        :param pulumi.Input[bool] imported: Is AKS cluster imported?
        :param pulumi.Input[str] kubernetes_version: The kubernetes master version. Required if `import=false`
        :param pulumi.Input[str] linux_admin_username: The AKS linux admin username
        :param pulumi.Input[str] linux_ssh_public_key: The AKS linux ssh public key
        :param pulumi.Input[str] load_balancer_sku: The AKS load balancer sku
        :param pulumi.Input[str] log_analytics_workspace_group: The AKS log analytics workspace group
        :param pulumi.Input[str] log_analytics_workspace_name: The AKS log analytics workspace name
        :param pulumi.Input[bool] monitoring: Is AKS cluster monitoring enabled?
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[str] network_dns_service_ip: The AKS network dns service ip
        :param pulumi.Input[str] network_docker_bridge_cidr: The AKS network docker bridge cidr
        :param pulumi.Input[str] network_plugin: The AKS network plugin. Required if `import=false`
        :param pulumi.Input[str] network_pod_cidr: The AKS network pod cidr
        :param pulumi.Input[str] network_policy: The AKS network policy
        :param pulumi.Input[str] network_service_cidr: The AKS network service cidr
        :param pulumi.Input[Sequence[pulumi.Input['ClusterAksConfigV2NodePoolArgs']]] node_pools: The AKS node pools to use. Required if `import=false`
        :param pulumi.Input[bool] private_cluster: Is AKS cluster private?
        :param pulumi.Input[str] subnet: The AKS subnet
        :param pulumi.Input[Mapping[str, Any]] tags: The AKS cluster tags
        :param pulumi.Input[str] virtual_network: The AKS virtual network
        :param pulumi.Input[str] virtual_network_resource_group: The AKS virtual network resource group
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "resource_location", resource_location)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if authorized_ip_ranges is not None:
            pulumi.set(__self__, "authorized_ip_ranges", authorized_ip_ranges)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if dns_prefix is not None:
            pulumi.set(__self__, "dns_prefix", dns_prefix)
        if http_application_routing is not None:
            pulumi.set(__self__, "http_application_routing", http_application_routing)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if linux_admin_username is not None:
            pulumi.set(__self__, "linux_admin_username", linux_admin_username)
        if linux_ssh_public_key is not None:
            pulumi.set(__self__, "linux_ssh_public_key", linux_ssh_public_key)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if log_analytics_workspace_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_group", log_analytics_workspace_group)
        if log_analytics_workspace_name is not None:
            pulumi.set(__self__, "log_analytics_workspace_name", log_analytics_workspace_name)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_dns_service_ip is not None:
            pulumi.set(__self__, "network_dns_service_ip", network_dns_service_ip)
        if network_docker_bridge_cidr is not None:
            pulumi.set(__self__, "network_docker_bridge_cidr", network_docker_bridge_cidr)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_pod_cidr is not None:
            pulumi.set(__self__, "network_pod_cidr", network_pod_cidr)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if network_service_cidr is not None:
            pulumi.set(__self__, "network_service_cidr", network_service_cidr)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)
        if private_cluster is not None:
            pulumi.set(__self__, "private_cluster", private_cluster)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if virtual_network is not None:
            pulumi.set(__self__, "virtual_network", virtual_network)
        if virtual_network_resource_group is not None:
            pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)

    @property
    @pulumi.getter(name="cloudCredentialId")
    def cloud_credential_id(self) -> pulumi.Input[str]:
        """
        The AKS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

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

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> pulumi.Input[str]:
        """
        The AKS resource group
        """
        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="resourceLocation")
    def resource_location(self) -> pulumi.Input[str]:
        """
        The AKS resource location
        """
        return pulumi.get(self, "resource_location")

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

    @property
    @pulumi.getter(name="authBaseUrl")
    def auth_base_url(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS auth base url
        """
        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="authorizedIpRanges")
    def authorized_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The AKS authorized ip ranges
        """
        return pulumi.get(self, "authorized_ip_ranges")

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

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS base url
        """
        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(name="dnsPrefix")
    def dns_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS dns prefix. Required if `import=false`
        """
        return pulumi.get(self, "dns_prefix")

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

    @property
    @pulumi.getter(name="httpApplicationRouting")
    def http_application_routing(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable AKS http application routing?
        """
        return pulumi.get(self, "http_application_routing")

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

    @property
    @pulumi.getter
    def imported(self) -> Optional[pulumi.Input[bool]]:
        """
        Is AKS cluster imported?
        """
        return pulumi.get(self, "imported")

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
        """
        The kubernetes master version. Required if `import=false`
        """
        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(name="linuxAdminUsername")
    def linux_admin_username(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS linux admin username
        """
        return pulumi.get(self, "linux_admin_username")

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

    @property
    @pulumi.getter(name="linuxSshPublicKey")
    def linux_ssh_public_key(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS linux ssh public key
        """
        return pulumi.get(self, "linux_ssh_public_key")

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

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS load balancer sku
        """
        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(name="logAnalyticsWorkspaceGroup")
    def log_analytics_workspace_group(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS log analytics workspace group
        """
        return pulumi.get(self, "log_analytics_workspace_group")

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

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceName")
    def log_analytics_workspace_name(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS log analytics workspace name
        """
        return pulumi.get(self, "log_analytics_workspace_name")

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

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Is AKS cluster monitoring enabled?
        """
        return pulumi.get(self, "monitoring")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Cluster (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="networkDnsServiceIp")
    def network_dns_service_ip(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS network dns service ip
        """
        return pulumi.get(self, "network_dns_service_ip")

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

    @property
    @pulumi.getter(name="networkDockerBridgeCidr")
    def network_docker_bridge_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS network docker bridge cidr
        """
        return pulumi.get(self, "network_docker_bridge_cidr")

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

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS network plugin. Required if `import=false`
        """
        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="networkPodCidr")
    def network_pod_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS network pod cidr
        """
        return pulumi.get(self, "network_pod_cidr")

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

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS network policy
        """
        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="networkServiceCidr")
    def network_service_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS network service cidr
        """
        return pulumi.get(self, "network_service_cidr")

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

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterAksConfigV2NodePoolArgs']]]]:
        """
        The AKS node pools to use. Required if `import=false`
        """
        return pulumi.get(self, "node_pools")

    @node_pools.setter
    def node_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterAksConfigV2NodePoolArgs']]]]):
        pulumi.set(self, "node_pools", value)

    @property
    @pulumi.getter(name="privateCluster")
    def private_cluster(self) -> Optional[pulumi.Input[bool]]:
        """
        Is AKS cluster private?
        """
        return pulumi.get(self, "private_cluster")

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

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

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

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

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

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS virtual network
        """
        return pulumi.get(self, "virtual_network")

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

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS virtual network resource group
        """
        return pulumi.get(self, "virtual_network_resource_group")

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


@pulumi.input_type
class ClusterAksConfigV2NodePoolArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 count: Optional[pulumi.Input[int]] = None,
                 enable_auto_scaling: Optional[pulumi.Input[bool]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 max_count: Optional[pulumi.Input[int]] = None,
                 max_pods: Optional[pulumi.Input[int]] = None,
                 max_surge: Optional[pulumi.Input[str]] = None,
                 min_count: Optional[pulumi.Input[int]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 orchestrator_version: Optional[pulumi.Input[str]] = None,
                 os_disk_size_gb: Optional[pulumi.Input[int]] = None,
                 os_disk_type: Optional[pulumi.Input[str]] = None,
                 os_type: Optional[pulumi.Input[str]] = None,
                 taints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 vm_size: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: The AKS node pool availability zones
        :param pulumi.Input[int] count: The AKS node pool count
        :param pulumi.Input[bool] enable_auto_scaling: Is AKS node pool auto scaling enabled?
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster (map)
        :param pulumi.Input[int] max_count: The AKS node pool max count
        :param pulumi.Input[int] max_pods: The AKS node pool max pods
        :param pulumi.Input[str] max_surge: The AKS node pool max surge
        :param pulumi.Input[int] min_count: The AKS node pool min count
        :param pulumi.Input[str] mode: The AKS node pool mode
        :param pulumi.Input[str] orchestrator_version: The AKS node pool orchestrator version
        :param pulumi.Input[int] os_disk_size_gb: The AKS node pool os disk size gb
        :param pulumi.Input[str] os_disk_type: The AKS node pool os disk type
        :param pulumi.Input[str] os_type: Enable AKS node pool os type
        :param pulumi.Input[Sequence[pulumi.Input[str]]] taints: The AKS node pool taints
        :param pulumi.Input[str] vm_size: The AKS node pool vm size
        """
        pulumi.set(__self__, "name", name)
        if availability_zones is not None:
            pulumi.set(__self__, "availability_zones", availability_zones)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if enable_auto_scaling is not None:
            pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if max_count is not None:
            pulumi.set(__self__, "max_count", max_count)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if orchestrator_version is not None:
            pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if os_disk_type is not None:
            pulumi.set(__self__, "os_disk_type", os_disk_type)
        if os_type is not None:
            pulumi.set(__self__, "os_type", os_type)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if vm_size is not None:
            pulumi.set(__self__, "vm_size", vm_size)

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

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

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The AKS node pool availability zones
        """
        return pulumi.get(self, "availability_zones")

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

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[int]]:
        """
        The AKS node pool count
        """
        return pulumi.get(self, "count")

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

    @property
    @pulumi.getter(name="enableAutoScaling")
    def enable_auto_scaling(self) -> Optional[pulumi.Input[bool]]:
        """
        Is AKS node pool auto scaling enabled?
        """
        return pulumi.get(self, "enable_auto_scaling")

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster (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="maxCount")
    def max_count(self) -> Optional[pulumi.Input[int]]:
        """
        The AKS node pool max count
        """
        return pulumi.get(self, "max_count")

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

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[pulumi.Input[int]]:
        """
        The AKS node pool max pods
        """
        return pulumi.get(self, "max_pods")

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

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS node pool max surge
        """
        return pulumi.get(self, "max_surge")

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

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> Optional[pulumi.Input[int]]:
        """
        The AKS node pool min count
        """
        return pulumi.get(self, "min_count")

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

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS node pool mode
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter(name="orchestratorVersion")
    def orchestrator_version(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS node pool orchestrator version
        """
        return pulumi.get(self, "orchestrator_version")

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

    @property
    @pulumi.getter(name="osDiskSizeGb")
    def os_disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        The AKS node pool os disk size gb
        """
        return pulumi.get(self, "os_disk_size_gb")

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

    @property
    @pulumi.getter(name="osDiskType")
    def os_disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS node pool os disk type
        """
        return pulumi.get(self, "os_disk_type")

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

    @property
    @pulumi.getter(name="osType")
    def os_type(self) -> Optional[pulumi.Input[str]]:
        """
        Enable AKS node pool os type
        """
        return pulumi.get(self, "os_type")

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

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The AKS node pool taints
        """
        return pulumi.get(self, "taints")

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

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> Optional[pulumi.Input[str]]:
        """
        The AKS node pool vm size
        """
        return pulumi.get(self, "vm_size")

    @vm_size.setter
    def vm_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vm_size", 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
        :param pulumi.Input[bool] default_recipient: Use notifier default recipient
        :param pulumi.Input[str] notifier_type: Recipient notifier type
        :param pulumi.Input[str] recipient: Recipient
        """
        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
        """
        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
        """
        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 type
        """
        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
        """
        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
        :param pulumi.Input[str] event_type: Event type
        """
        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
        """
        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
        """
        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
        :param pulumi.Input[str] expression: Metric rule expression
        :param pulumi.Input[float] threshold_value: Metric rule threshold value
        :param pulumi.Input[str] comparison: Metric rule comparison
        :param pulumi.Input[str] description: Metric rule description
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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[int]] = None,
                 mem_threshold: Optional[pulumi.Input[int]] = None,
                 node_id: Optional[pulumi.Input[str]] = None,
                 selector: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] condition: Node rule condition
        :param pulumi.Input[int] cpu_threshold: Node rule cpu threshold
        :param pulumi.Input[int] mem_threshold: Node rule mem threshold
        :param pulumi.Input[str] node_id: Node ID
        :param pulumi.Input[Mapping[str, Any]] selector: Node rule selector
        """
        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]]:
        """
        Node rule condition
        """
        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[int]]:
        """
        Node rule cpu threshold
        """
        return pulumi.get(self, "cpu_threshold")

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

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

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

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[str]]:
        """
        Node ID
        """
        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
        """
        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
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

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

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


@pulumi.input_type
class ClusterClusterAgentDeploymentCustomizationArgs:
    def __init__(__self__, *,
                 append_tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs']]]] = None,
                 override_affinity: Optional[pulumi.Input[str]] = None,
                 override_resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs']]] append_tolerations: User defined tolerations to append to agent
        :param pulumi.Input[str] override_affinity: User defined affinity to override default agent affinity
        :param pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]] override_resource_requirements: User defined resource requirements to set on the agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)

    @property
    @pulumi.getter(name="appendTolerations")
    def append_tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs']]]]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @append_tolerations.setter
    def append_tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs']]]]):
        pulumi.set(self, "append_tolerations", value)

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        User defined affinity to override default agent affinity
        """
        return pulumi.get(self, "override_affinity")

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

    @property
    @pulumi.getter(name="overrideResourceRequirements")
    def override_resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]:
        """
        User defined resource requirements to set on the agent
        """
        return pulumi.get(self, "override_resource_requirements")

    @override_resource_requirements.setter
    def override_resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]):
        pulumi.set(self, "override_resource_requirements", value)


@pulumi.input_type
class ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs:
    def __init__(__self__, *,
                 cpu_limit: Optional[pulumi.Input[str]] = None,
                 cpu_request: Optional[pulumi.Input[str]] = None,
                 memory_limit: Optional[pulumi.Input[str]] = None,
                 memory_request: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cpu_limit: The maximum CPU limit for agent
        :param pulumi.Input[str] cpu_request: The minimum CPU required for agent
        :param pulumi.Input[str] memory_limit: The maximum memory limit for agent
        :param pulumi.Input[str] memory_request: The minimum memory required for agent
        """
        if cpu_limit is not None:
            pulumi.set(__self__, "cpu_limit", cpu_limit)
        if cpu_request is not None:
            pulumi.set(__self__, "cpu_request", cpu_request)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if memory_request is not None:
            pulumi.set(__self__, "memory_request", memory_request)

    @property
    @pulumi.getter(name="cpuLimit")
    def cpu_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

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

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

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

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

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

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")

    @memory_request.setter
    def memory_request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_request", 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):
        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]]:
        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 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: Answers for monitor input
        :param pulumi.Input[str] version: Monitoring version
        """
        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]]]:
        """
        Answers for monitor input
        """
        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]]:
        """
        Monitoring version
        """
        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,
                 insecure_node_command: Optional[pulumi.Input[str]] = None,
                 insecure_windows_node_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 the Cluster (map)
        :param pulumi.Input[str] id: (Computed) The ID of the resource (string)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster (map)
        :param pulumi.Input[str] name: The name of the 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 insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_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 the Cluster (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]]:
        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]]:
        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]]:
        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(name="insecureNodeCommand")
    def insecure_node_command(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "insecure_node_command")

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

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

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster (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]]:
        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]]:
        """
        The name of the Cluster (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]]:
        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]]:
        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]]:
        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 for answer
        :param pulumi.Input[str] project_id: Project ID for answer
        :param pulumi.Input[Mapping[str, Any]] values: Key/values for answer
        """
        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
        """
        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 answer
        """
        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
        """
        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
        :param pulumi.Input[str] variable: Variable name
        :param pulumi.Input[bool] required: Required variable
        :param pulumi.Input[str] type: Variable type
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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[int]] = None,
                 ebs_encryption: Optional[pulumi.Input[bool]] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 key_pair_name: Optional[pulumi.Input[str]] = None,
                 maximum_nodes: Optional[pulumi.Input[int]] = None,
                 minimum_nodes: Optional[pulumi.Input[int]] = None,
                 node_volume_size: Optional[pulumi.Input[int]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_role: Optional[pulumi.Input[str]] = None,
                 session_token: Optional[pulumi.Input[str]] = None,
                 subnets: Optional[pulumi.Input[Sequence[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
        :param pulumi.Input[str] kubernetes_version: The kubernetes master version
        :param pulumi.Input[str] secret_key: The AWS Client Secret associated with the Client ID
        :param pulumi.Input[str] ami: A custom AMI ID to use for the worker nodes instead of the default
        :param pulumi.Input[bool] associate_worker_node_public_ip: Associate public ip EKS worker nodes
        :param pulumi.Input[int] desired_nodes: The desired number of worker nodes
        :param pulumi.Input[bool] ebs_encryption: Enables EBS encryption of worker nodes
        :param pulumi.Input[str] instance_type: The type of machine to use for worker nodes
        :param pulumi.Input[str] key_pair_name: Allow user to specify key name to use
        :param pulumi.Input[int] maximum_nodes: The maximum number of worker nodes
        :param pulumi.Input[int] minimum_nodes: The minimum number of worker nodes
        :param pulumi.Input[int] node_volume_size: The volume size for each node
        :param pulumi.Input[str] region: The AWS Region to create the EKS cluster in
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: List of security groups to use for the cluster
        :param pulumi.Input[str] service_role: The service role to use to perform the cluster operations in AWS
        :param pulumi.Input[str] session_token: A session token to use with the client key and secret if applicable
        :param pulumi.Input[Sequence[pulumi.Input[str]]] subnets: List of subnets in the virtual network to use
        :param pulumi.Input[str] user_data: Pass user-data to the nodes to perform automated configuration tasks
        :param pulumi.Input[str] virtual_network: The name of the virtual network to use
        """
        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 ebs_encryption is not None:
            pulumi.set(__self__, "ebs_encryption", ebs_encryption)
        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
        """
        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
        """
        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
        """
        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]]:
        """
        A custom AMI ID to use for the worker nodes instead of the default
        """
        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
        """
        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[int]]:
        """
        The desired number of worker nodes
        """
        return pulumi.get(self, "desired_nodes")

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

    @property
    @pulumi.getter(name="ebsEncryption")
    def ebs_encryption(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables EBS encryption of worker nodes
        """
        return pulumi.get(self, "ebs_encryption")

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

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of machine to use for worker nodes
        """
        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
        """
        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[int]]:
        """
        The maximum number of worker nodes
        """
        return pulumi.get(self, "maximum_nodes")

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

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

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

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

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS Region to create the EKS cluster in
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        List of security groups to use for the cluster
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: Optional[pulumi.Input[Sequence[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
        """
        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
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

    @subnets.setter
    def subnets(self, value: Optional[pulumi.Input[Sequence[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
        """
        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
        """
        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 ClusterEksConfigV2Args:
    def __init__(__self__, *,
                 cloud_credential_id: pulumi.Input[str],
                 imported: Optional[pulumi.Input[bool]] = None,
                 kms_key: Optional[pulumi.Input[str]] = None,
                 kubernetes_version: Optional[pulumi.Input[str]] = None,
                 logging_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 node_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupArgs']]]] = None,
                 private_access: Optional[pulumi.Input[bool]] = None,
                 public_access: Optional[pulumi.Input[bool]] = None,
                 public_access_sources: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 secrets_encryption: Optional[pulumi.Input[bool]] = None,
                 security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_role: Optional[pulumi.Input[str]] = None,
                 subnets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 tags: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] cloud_credential_id: The AWS Cloud Credential ID to use
        :param pulumi.Input[bool] imported: Is EKS cluster imported?
        :param pulumi.Input[str] kms_key: The AWS kms key to use
        :param pulumi.Input[str] kubernetes_version: The kubernetes master version
        :param pulumi.Input[Sequence[pulumi.Input[str]]] logging_types: The AWS logging types
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupArgs']]] node_groups: The AWS node groups to use
        :param pulumi.Input[bool] private_access: The EKS cluster has private access
        :param pulumi.Input[bool] public_access: The EKS cluster has public access
        :param pulumi.Input[Sequence[pulumi.Input[str]]] public_access_sources: The EKS cluster public access sources
        :param pulumi.Input[str] region: The AWS Region to create the EKS cluster in
        :param pulumi.Input[bool] secrets_encryption: Enable EKS cluster secret encryption
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: List of security groups to use for the cluster
        :param pulumi.Input[str] service_role: The AWS service role to use
        :param pulumi.Input[Sequence[pulumi.Input[str]]] subnets: List of subnets in the virtual network to use
        :param pulumi.Input[Mapping[str, Any]] tags: The EKS cluster tags
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if logging_types is not None:
            pulumi.set(__self__, "logging_types", logging_types)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_groups is not None:
            pulumi.set(__self__, "node_groups", node_groups)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if public_access_sources is not None:
            pulumi.set(__self__, "public_access_sources", public_access_sources)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secrets_encryption is not None:
            pulumi.set(__self__, "secrets_encryption", secrets_encryption)
        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 subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="cloudCredentialId")
    def cloud_credential_id(self) -> pulumi.Input[str]:
        """
        The AWS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

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

    @property
    @pulumi.getter
    def imported(self) -> Optional[pulumi.Input[bool]]:
        """
        Is EKS cluster imported?
        """
        return pulumi.get(self, "imported")

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

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS kms key to use
        """
        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(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
        """
        The kubernetes master version
        """
        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(name="loggingTypes")
    def logging_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The AWS logging types
        """
        return pulumi.get(self, "logging_types")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Cluster (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="nodeGroups")
    def node_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupArgs']]]]:
        """
        The AWS node groups to use
        """
        return pulumi.get(self, "node_groups")

    @node_groups.setter
    def node_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupArgs']]]]):
        pulumi.set(self, "node_groups", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input[bool]]:
        """
        The EKS cluster has private access
        """
        return pulumi.get(self, "private_access")

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

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input[bool]]:
        """
        The EKS cluster has public access
        """
        return pulumi.get(self, "public_access")

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

    @property
    @pulumi.getter(name="publicAccessSources")
    def public_access_sources(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The EKS cluster public access sources
        """
        return pulumi.get(self, "public_access_sources")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS Region to create the EKS cluster in
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="secretsEncryption")
    def secrets_encryption(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable EKS cluster secret encryption
        """
        return pulumi.get(self, "secrets_encryption")

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

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of security groups to use for the cluster
        """
        return pulumi.get(self, "security_groups")

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

    @property
    @pulumi.getter(name="serviceRole")
    def service_role(self) -> Optional[pulumi.Input[str]]:
        """
        The AWS service role to use
        """
        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
    def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

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

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

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


@pulumi.input_type
class ClusterEksConfigV2NodeGroupArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 desired_size: Optional[pulumi.Input[int]] = None,
                 disk_size: Optional[pulumi.Input[int]] = None,
                 ec2_ssh_key: Optional[pulumi.Input[str]] = None,
                 gpu: Optional[pulumi.Input[bool]] = None,
                 image_id: Optional[pulumi.Input[str]] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 launch_templates: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupLaunchTemplateArgs']]]] = None,
                 max_size: Optional[pulumi.Input[int]] = None,
                 min_size: Optional[pulumi.Input[int]] = None,
                 node_role: Optional[pulumi.Input[str]] = None,
                 request_spot_instances: Optional[pulumi.Input[bool]] = None,
                 resource_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 spot_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 subnets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 user_data: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[int] desired_size: The EKS node group desired size
        :param pulumi.Input[int] disk_size: The EKS node group disk size
        :param pulumi.Input[str] ec2_ssh_key: The EKS node group ssh key
        :param pulumi.Input[bool] gpu: Is EKS cluster using gpu?
        :param pulumi.Input[str] image_id: The EKS node group image ID
        :param pulumi.Input[str] instance_type: The EKS node group instance type
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster (map)
        :param pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupLaunchTemplateArgs']]] launch_templates: The EKS node groups launch template
        :param pulumi.Input[int] max_size: The EKS node group maximum size
        :param pulumi.Input[int] min_size: The EKS node group minimum size
        :param pulumi.Input[str] node_role: The EKS node group node role ARN
        :param pulumi.Input[bool] request_spot_instances: Enable EKS node group request spot instances
        :param pulumi.Input[Mapping[str, Any]] resource_tags: The EKS node group resource tags
        :param pulumi.Input[Sequence[pulumi.Input[str]]] spot_instance_types: The EKS node group spot instance types
        :param pulumi.Input[Sequence[pulumi.Input[str]]] subnets: The EKS node group subnets
        :param pulumi.Input[Mapping[str, Any]] tags: The EKS node group tags
        :param pulumi.Input[str] user_data: The EKS node group user data
        :param pulumi.Input[str] version: The EKS node group k8s version
        """
        pulumi.set(__self__, "name", name)
        if desired_size is not None:
            pulumi.set(__self__, "desired_size", desired_size)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if ec2_ssh_key is not None:
            pulumi.set(__self__, "ec2_ssh_key", ec2_ssh_key)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if launch_templates is not None:
            pulumi.set(__self__, "launch_templates", launch_templates)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if node_role is not None:
            pulumi.set(__self__, "node_role", node_role)
        if request_spot_instances is not None:
            pulumi.set(__self__, "request_spot_instances", request_spot_instances)
        if resource_tags is not None:
            pulumi.set(__self__, "resource_tags", resource_tags)
        if spot_instance_types is not None:
            pulumi.set(__self__, "spot_instance_types", spot_instance_types)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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

    @property
    @pulumi.getter(name="desiredSize")
    def desired_size(self) -> Optional[pulumi.Input[int]]:
        """
        The EKS node group desired size
        """
        return pulumi.get(self, "desired_size")

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

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[pulumi.Input[int]]:
        """
        The EKS node group disk size
        """
        return pulumi.get(self, "disk_size")

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

    @property
    @pulumi.getter(name="ec2SshKey")
    def ec2_ssh_key(self) -> Optional[pulumi.Input[str]]:
        """
        The EKS node group ssh key
        """
        return pulumi.get(self, "ec2_ssh_key")

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

    @property
    @pulumi.getter
    def gpu(self) -> Optional[pulumi.Input[bool]]:
        """
        Is EKS cluster using gpu?
        """
        return pulumi.get(self, "gpu")

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

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[pulumi.Input[str]]:
        """
        The EKS node group image ID
        """
        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="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        The EKS node group instance type
        """
        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 labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster (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="launchTemplates")
    def launch_templates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupLaunchTemplateArgs']]]]:
        """
        The EKS node groups launch template
        """
        return pulumi.get(self, "launch_templates")

    @launch_templates.setter
    def launch_templates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEksConfigV2NodeGroupLaunchTemplateArgs']]]]):
        pulumi.set(self, "launch_templates", value)

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[int]]:
        """
        The EKS node group maximum size
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[pulumi.Input[int]]:
        """
        The EKS node group minimum size
        """
        return pulumi.get(self, "min_size")

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

    @property
    @pulumi.getter(name="nodeRole")
    def node_role(self) -> Optional[pulumi.Input[str]]:
        """
        The EKS node group node role ARN
        """
        return pulumi.get(self, "node_role")

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

    @property
    @pulumi.getter(name="requestSpotInstances")
    def request_spot_instances(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable EKS node group request spot instances
        """
        return pulumi.get(self, "request_spot_instances")

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

    @property
    @pulumi.getter(name="resourceTags")
    def resource_tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        The EKS node group resource tags
        """
        return pulumi.get(self, "resource_tags")

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

    @property
    @pulumi.getter(name="spotInstanceTypes")
    def spot_instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The EKS node group spot instance types
        """
        return pulumi.get(self, "spot_instance_types")

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

    @property
    @pulumi.getter
    def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The EKS node group subnets
        """
        return pulumi.get(self, "subnets")

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

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        The EKS node group tags
        """
        return pulumi.get(self, "tags")

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

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[pulumi.Input[str]]:
        """
        The EKS node group user data
        """
        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
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        The EKS node group k8s version
        """
        return pulumi.get(self, "version")

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


@pulumi.input_type
class ClusterEksConfigV2NodeGroupLaunchTemplateArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 name: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] id: (Computed) The ID of the resource (string)
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[int] version: The EKS node group launch template version
        """
        pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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

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

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

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[int]]:
        """
        The EKS node group launch template version
        """
        return pulumi.get(self, "version")

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


@pulumi.input_type
class ClusterFleetAgentDeploymentCustomizationArgs:
    def __init__(__self__, *,
                 append_tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs']]]] = None,
                 override_affinity: Optional[pulumi.Input[str]] = None,
                 override_resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs']]] append_tolerations: User defined tolerations to append to agent
        :param pulumi.Input[str] override_affinity: User defined affinity to override default agent affinity
        :param pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]] override_resource_requirements: User defined resource requirements to set on the agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)

    @property
    @pulumi.getter(name="appendTolerations")
    def append_tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs']]]]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @append_tolerations.setter
    def append_tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs']]]]):
        pulumi.set(self, "append_tolerations", value)

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        User defined affinity to override default agent affinity
        """
        return pulumi.get(self, "override_affinity")

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

    @property
    @pulumi.getter(name="overrideResourceRequirements")
    def override_resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]:
        """
        User defined resource requirements to set on the agent
        """
        return pulumi.get(self, "override_resource_requirements")

    @override_resource_requirements.setter
    def override_resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]):
        pulumi.set(self, "override_resource_requirements", value)


@pulumi.input_type
class ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirementArgs:
    def __init__(__self__, *,
                 cpu_limit: Optional[pulumi.Input[str]] = None,
                 cpu_request: Optional[pulumi.Input[str]] = None,
                 memory_limit: Optional[pulumi.Input[str]] = None,
                 memory_request: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cpu_limit: The maximum CPU limit for agent
        :param pulumi.Input[str] cpu_request: The minimum CPU required for agent
        :param pulumi.Input[str] memory_limit: The maximum memory limit for agent
        :param pulumi.Input[str] memory_request: The minimum memory required for agent
        """
        if cpu_limit is not None:
            pulumi.set(__self__, "cpu_limit", cpu_limit)
        if cpu_request is not None:
            pulumi.set(__self__, "cpu_request", cpu_request)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if memory_request is not None:
            pulumi.set(__self__, "memory_request", memory_request)

    @property
    @pulumi.getter(name="cpuLimit")
    def cpu_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

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

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

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

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

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

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")

    @memory_request.setter
    def memory_request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_request", 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[Sequence[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[Sequence[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[int]] = 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[int]] = None,
                 master_authorized_network_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_node_count: Optional[pulumi.Input[int]] = None,
                 min_node_count: Optional[pulumi.Input[int]] = None,
                 node_count: Optional[pulumi.Input[int]] = 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[Sequence[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
        :param pulumi.Input[str] credential: The contents of the GC credential file
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node
        :param pulumi.Input[str] image_type: The image to use for the worker nodes
        :param pulumi.Input[str] ip_policy_cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs
        :param pulumi.Input[str] ip_policy_cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block
        :param pulumi.Input[str] ip_policy_node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster
        :param pulumi.Input[str] ip_policy_services_ipv4_cidr_block: The IP address range of the services IPs in this cluster
        :param pulumi.Input[str] ip_policy_services_secondary_range_name: The name of the secondary range to be used for the services CIDR block
        :param pulumi.Input[str] ip_policy_subnetwork_name: A custom subnetwork name to be used if createSubnetwork is true
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: Locations to use for the cluster
        :param pulumi.Input[str] machine_type: The machine type to use for the worker nodes
        :param pulumi.Input[str] maintenance_window: When to performance updates on the nodes, in 24-hour time
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network
        :param pulumi.Input[str] master_version: The kubernetes master version
        :param pulumi.Input[str] network: The network to use for the cluster
        :param pulumi.Input[str] node_pool: The ID of the cluster node pool
        :param pulumi.Input[str] node_version: The version of kubernetes to use on the nodes
        :param pulumi.Input[Sequence[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
        :param pulumi.Input[str] project_id: The ID of your project to use when creating a cluster
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs
        :param pulumi.Input[str] sub_network: The sub-network to use for the cluster
        :param pulumi.Input[str] description: The description for Cluster (string)
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node
        :param pulumi.Input[bool] enable_alpha_feature: To enable kubernetes alpha feature
        :param pulumi.Input[bool] enable_auto_repair: Specifies whether the node auto-repair is enabled for the node pool
        :param pulumi.Input[bool] enable_auto_upgrade: Specifies whether node auto-upgrade is enabled for the node pool
        :param pulumi.Input[bool] enable_horizontal_pod_autoscaling: Enable horizontal pod autoscaling for the cluster
        :param pulumi.Input[bool] enable_http_load_balancing: Enable http load balancing for the cluster
        :param pulumi.Input[bool] enable_kubernetes_dashboard: Whether to enable the kubernetes dashboard
        :param pulumi.Input[bool] enable_legacy_abac: Whether to enable legacy abac on the cluster
        :param pulumi.Input[bool] enable_master_authorized_network: Whether or not master authorized network is enabled
        :param pulumi.Input[bool] enable_network_policy_config: Enable network policy config for the cluster
        :param pulumi.Input[bool] enable_nodepool_autoscaling: Enable nodepool autoscaling
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP address only
        :param pulumi.Input[bool] enable_stackdriver_logging: Enable stackdriver logging
        :param pulumi.Input[bool] enable_stackdriver_monitoring: Enable stackdriver monitoring
        :param pulumi.Input[bool] ip_policy_create_subnetwork: Whether a new subnetwork will be created automatically for the cluster
        :param pulumi.Input[bool] issue_client_certificate: Issue a client certificate
        :param pulumi.Input[bool] kubernetes_dashboard: Enable the kubernetes dashboard
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster (map)
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node
        :param pulumi.Input[Sequence[pulumi.Input[str]]] master_authorized_network_cidr_blocks: Define up to 10 external networks that could access Kubernetes master through HTTPS
        :param pulumi.Input[int] max_node_count: Maximum number of nodes in the NodePool. Must be >= minNodeCount. There has to enough quota to scale up the cluster
        :param pulumi.Input[int] min_node_count: Minimmum number of nodes in the NodePool. Must be >= 1 and <= maxNodeCount
        :param pulumi.Input[int] node_count: The number of nodes to create in this cluster
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances
        :param pulumi.Input[str] region: The region to launch the cluster. Region or zone should be used
        :param pulumi.Input[Mapping[str, Any]] resource_labels: The map of Kubernetes labels (key/value pairs) to be applied to each cluster
        :param pulumi.Input[Sequence[pulumi.Input[str]]] taints: List of kubernetes taints to be applied to each node
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster
        :param pulumi.Input[str] zone: The zone to launch the cluster. Zone or region should be used
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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[Sequence[pulumi.Input[str]]]:
        """
        Locations to use for the cluster
        """
        return pulumi.get(self, "locations")

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

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> pulumi.Input[str]:
        """
        The machine type to use for the worker nodes
        """
        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]:
        """
        When to performance updates on the nodes, in 24-hour time
        """
        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
        """
        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]:
        """
        The kubernetes master version
        """
        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]:
        """
        The network to use for the cluster
        """
        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
        """
        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]:
        """
        The version of kubernetes to use on the nodes
        """
        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[Sequence[pulumi.Input[str]]]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the default service account
        """
        return pulumi.get(self, "oauth_scopes")

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        The ID of your project to use when creating a cluster
        """
        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
        """
        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]:
        """
        The sub-network to use for the cluster
        """
        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]]:
        """
        The description for 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[int]]:
        """
        Size of the disk attached to each node
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        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
        """
        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
        """
        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
        """
        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
        """
        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 for the cluster
        """
        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
        """
        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
        """
        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]]:
        """
        Whether or not master authorized network is enabled
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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 logging
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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 the Cluster (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[int]]:
        """
        The number of local SSD disks to be attached to the node
        """
        return pulumi.get(self, "local_ssd_count")

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

    @property
    @pulumi.getter(name="masterAuthorizedNetworkCidrBlocks")
    def master_authorized_network_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Define up to 10 external networks that could access Kubernetes master through HTTPS
        """
        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[Sequence[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[int]]:
        """
        Maximum number of nodes in the NodePool. Must be >= minNodeCount. There has to enough quota to scale up the cluster
        """
        return pulumi.get(self, "max_node_count")

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

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

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

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of nodes to create in this cluster
        """
        return pulumi.get(self, "node_count")

    @node_count.setter
    def node_count(self, value: Optional[pulumi.Input[int]]):
        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
        """
        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]]:
        """
        The region to launch the cluster. Region or zone should be used
        """
        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 (key/value pairs) to be applied to each cluster
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        List of kubernetes taints to be applied to each node
        """
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[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
        """
        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]]:
        """
        The zone to launch the cluster. Zone or region should be used
        """
        return pulumi.get(self, "zone")

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


@pulumi.input_type
class ClusterGkeConfigV2Args:
    def __init__(__self__, *,
                 google_credential_secret: pulumi.Input[str],
                 name: pulumi.Input[str],
                 project_id: pulumi.Input[str],
                 cluster_addons: Optional[pulumi.Input['ClusterGkeConfigV2ClusterAddonsArgs']] = None,
                 cluster_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 enable_kubernetes_alpha: Optional[pulumi.Input[bool]] = None,
                 imported: Optional[pulumi.Input[bool]] = None,
                 ip_allocation_policy: Optional[pulumi.Input['ClusterGkeConfigV2IpAllocationPolicyArgs']] = None,
                 kubernetes_version: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 logging_service: Optional[pulumi.Input[str]] = None,
                 maintenance_window: Optional[pulumi.Input[str]] = None,
                 master_authorized_networks_config: Optional[pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs']] = None,
                 monitoring_service: Optional[pulumi.Input[str]] = None,
                 network: Optional[pulumi.Input[str]] = None,
                 network_policy_enabled: Optional[pulumi.Input[bool]] = None,
                 node_pools: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolArgs']]]] = None,
                 private_cluster_config: Optional[pulumi.Input['ClusterGkeConfigV2PrivateClusterConfigArgs']] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 subnetwork: Optional[pulumi.Input[str]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] google_credential_secret: Google credential secret
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[str] project_id: The GKE project id
        :param pulumi.Input['ClusterGkeConfigV2ClusterAddonsArgs'] cluster_addons: The GKE cluster addons
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The GKE ip v4 cidr block
        :param pulumi.Input[str] description: The description for Cluster (string)
        :param pulumi.Input[bool] enable_kubernetes_alpha: Enable Kubernetes alpha
        :param pulumi.Input[bool] imported: Is GKE cluster imported?
        :param pulumi.Input['ClusterGkeConfigV2IpAllocationPolicyArgs'] ip_allocation_policy: The GKE ip allocation policy
        :param pulumi.Input[str] kubernetes_version: The kubernetes master version
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster (map)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The GKE cluster locations
        :param pulumi.Input[str] logging_service: The GKE cluster logging service
        :param pulumi.Input[str] maintenance_window: The GKE cluster maintenance window
        :param pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs'] master_authorized_networks_config: The GKE cluster master authorized networks config
        :param pulumi.Input[str] monitoring_service: The GKE cluster monitoring service
        :param pulumi.Input[str] network: The GKE cluster network
        :param pulumi.Input[bool] network_policy_enabled: Is GKE cluster network policy enabled?
        :param pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolArgs']]] node_pools: The GKE cluster node pools
        :param pulumi.Input['ClusterGkeConfigV2PrivateClusterConfigArgs'] private_cluster_config: The GKE private cluster config
        :param pulumi.Input[str] region: The GKE cluster region. Required if `zone` is empty
        :param pulumi.Input[str] subnetwork: The GKE cluster subnetwork
        :param pulumi.Input[str] zone: The GKE cluster zone. Required if `region` is empty
        """
        pulumi.set(__self__, "google_credential_secret", google_credential_secret)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "project_id", project_id)
        if cluster_addons is not None:
            pulumi.set(__self__, "cluster_addons", cluster_addons)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_alpha is not None:
            pulumi.set(__self__, "enable_kubernetes_alpha", enable_kubernetes_alpha)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if ip_allocation_policy is not None:
            pulumi.set(__self__, "ip_allocation_policy", ip_allocation_policy)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if logging_service is not None:
            pulumi.set(__self__, "logging_service", logging_service)
        if maintenance_window is not None:
            pulumi.set(__self__, "maintenance_window", maintenance_window)
        if master_authorized_networks_config is not None:
            pulumi.set(__self__, "master_authorized_networks_config", master_authorized_networks_config)
        if monitoring_service is not None:
            pulumi.set(__self__, "monitoring_service", monitoring_service)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_policy_enabled is not None:
            pulumi.set(__self__, "network_policy_enabled", network_policy_enabled)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)
        if private_cluster_config is not None:
            pulumi.set(__self__, "private_cluster_config", private_cluster_config)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="googleCredentialSecret")
    def google_credential_secret(self) -> pulumi.Input[str]:
        """
        Google credential secret
        """
        return pulumi.get(self, "google_credential_secret")

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

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

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        The GKE project id
        """
        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="clusterAddons")
    def cluster_addons(self) -> Optional[pulumi.Input['ClusterGkeConfigV2ClusterAddonsArgs']]:
        """
        The GKE cluster addons
        """
        return pulumi.get(self, "cluster_addons")

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

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE ip v4 cidr block
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        The description for 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="enableKubernetesAlpha")
    def enable_kubernetes_alpha(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Kubernetes alpha
        """
        return pulumi.get(self, "enable_kubernetes_alpha")

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

    @property
    @pulumi.getter
    def imported(self) -> Optional[pulumi.Input[bool]]:
        """
        Is GKE cluster imported?
        """
        return pulumi.get(self, "imported")

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

    @property
    @pulumi.getter(name="ipAllocationPolicy")
    def ip_allocation_policy(self) -> Optional[pulumi.Input['ClusterGkeConfigV2IpAllocationPolicyArgs']]:
        """
        The GKE ip allocation policy
        """
        return pulumi.get(self, "ip_allocation_policy")

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
        """
        The kubernetes master version
        """
        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 labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster (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 locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The GKE cluster locations
        """
        return pulumi.get(self, "locations")

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

    @property
    @pulumi.getter(name="loggingService")
    def logging_service(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster logging service
        """
        return pulumi.get(self, "logging_service")

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

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

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

    @property
    @pulumi.getter(name="masterAuthorizedNetworksConfig")
    def master_authorized_networks_config(self) -> Optional[pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs']]:
        """
        The GKE cluster master authorized networks config
        """
        return pulumi.get(self, "master_authorized_networks_config")

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

    @property
    @pulumi.getter(name="monitoringService")
    def monitoring_service(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster monitoring service
        """
        return pulumi.get(self, "monitoring_service")

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

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

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

    @property
    @pulumi.getter(name="networkPolicyEnabled")
    def network_policy_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Is GKE cluster network policy enabled?
        """
        return pulumi.get(self, "network_policy_enabled")

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

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolArgs']]]]:
        """
        The GKE cluster node pools
        """
        return pulumi.get(self, "node_pools")

    @node_pools.setter
    def node_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolArgs']]]]):
        pulumi.set(self, "node_pools", value)

    @property
    @pulumi.getter(name="privateClusterConfig")
    def private_cluster_config(self) -> Optional[pulumi.Input['ClusterGkeConfigV2PrivateClusterConfigArgs']]:
        """
        The GKE private cluster config
        """
        return pulumi.get(self, "private_cluster_config")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster region. Required if `zone` is empty
        """
        return pulumi.get(self, "region")

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

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

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

    @property
    @pulumi.getter
    def zone(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster zone. Required if `region` is empty
        """
        return pulumi.get(self, "zone")

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


@pulumi.input_type
class ClusterGkeConfigV2ClusterAddonsArgs:
    def __init__(__self__, *,
                 horizontal_pod_autoscaling: Optional[pulumi.Input[bool]] = None,
                 http_load_balancing: Optional[pulumi.Input[bool]] = None,
                 network_policy_config: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] horizontal_pod_autoscaling: Enable GKE horizontal pod autoscaling
        :param pulumi.Input[bool] http_load_balancing: Enable GKE HTTP load balancing
        :param pulumi.Input[bool] network_policy_config: Enable GKE network policy config
        """
        if horizontal_pod_autoscaling is not None:
            pulumi.set(__self__, "horizontal_pod_autoscaling", horizontal_pod_autoscaling)
        if http_load_balancing is not None:
            pulumi.set(__self__, "http_load_balancing", http_load_balancing)
        if network_policy_config is not None:
            pulumi.set(__self__, "network_policy_config", network_policy_config)

    @property
    @pulumi.getter(name="horizontalPodAutoscaling")
    def horizontal_pod_autoscaling(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE horizontal pod autoscaling
        """
        return pulumi.get(self, "horizontal_pod_autoscaling")

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

    @property
    @pulumi.getter(name="httpLoadBalancing")
    def http_load_balancing(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE HTTP load balancing
        """
        return pulumi.get(self, "http_load_balancing")

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

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE network policy config
        """
        return pulumi.get(self, "network_policy_config")

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


@pulumi.input_type
class ClusterGkeConfigV2IpAllocationPolicyArgs:
    def __init__(__self__, *,
                 cluster_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 cluster_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 create_subnetwork: Optional[pulumi.Input[bool]] = None,
                 node_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 services_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 services_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 subnetwork_name: Optional[pulumi.Input[str]] = None,
                 use_ip_aliases: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The GKE cluster ip v4 allocation cidr block
        :param pulumi.Input[str] cluster_secondary_range_name: The GKE cluster ip v4 allocation secondary range name
        :param pulumi.Input[bool] create_subnetwork: Create GKE subnetwork?
        :param pulumi.Input[str] node_ipv4_cidr_block: The GKE node ip v4 allocation cidr block
        :param pulumi.Input[str] services_ipv4_cidr_block: The GKE services ip v4 allocation cidr block
        :param pulumi.Input[str] services_secondary_range_name: The GKE services ip v4 allocation secondary range name
        :param pulumi.Input[str] subnetwork_name: The GKE cluster subnetwork name
        :param pulumi.Input[bool] use_ip_aliases: Use GKE ip aliases?
        """
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, "create_subnetwork", create_subnetwork)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, "node_ipv4_cidr_block", node_ipv4_cidr_block)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        if subnetwork_name is not None:
            pulumi.set(__self__, "subnetwork_name", subnetwork_name)
        if use_ip_aliases is not None:
            pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster ip v4 allocation cidr block
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

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

    @property
    @pulumi.getter(name="clusterSecondaryRangeName")
    def cluster_secondary_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster ip v4 allocation secondary range name
        """
        return pulumi.get(self, "cluster_secondary_range_name")

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

    @property
    @pulumi.getter(name="createSubnetwork")
    def create_subnetwork(self) -> Optional[pulumi.Input[bool]]:
        """
        Create GKE subnetwork?
        """
        return pulumi.get(self, "create_subnetwork")

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

    @property
    @pulumi.getter(name="nodeIpv4CidrBlock")
    def node_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE node ip v4 allocation cidr block
        """
        return pulumi.get(self, "node_ipv4_cidr_block")

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

    @property
    @pulumi.getter(name="servicesIpv4CidrBlock")
    def services_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE services ip v4 allocation cidr block
        """
        return pulumi.get(self, "services_ipv4_cidr_block")

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

    @property
    @pulumi.getter(name="servicesSecondaryRangeName")
    def services_secondary_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE services ip v4 allocation secondary range name
        """
        return pulumi.get(self, "services_secondary_range_name")

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

    @property
    @pulumi.getter(name="subnetworkName")
    def subnetwork_name(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE cluster subnetwork name
        """
        return pulumi.get(self, "subnetwork_name")

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

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[pulumi.Input[bool]]:
        """
        Use GKE ip aliases?
        """
        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)


@pulumi.input_type
class ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs:
    def __init__(__self__, *,
                 cidr_blocks: pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs']]],
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs']]] cidr_blocks: The GKE master authorized network config cidr blocks
        :param pulumi.Input[bool] enabled: Enable GKE master authorized network config
        """
        pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs']]]:
        """
        The GKE master authorized network config cidr blocks
        """
        return pulumi.get(self, "cidr_blocks")

    @cidr_blocks.setter
    def cidr_blocks(self, value: pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs']]]):
        pulumi.set(self, "cidr_blocks", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE master authorized network config
        """
        return pulumi.get(self, "enabled")

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


@pulumi.input_type
class ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs:
    def __init__(__self__, *,
                 cidr_block: pulumi.Input[str],
                 display_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cidr_block: The GKE master authorized network config cidr block
        :param pulumi.Input[str] display_name: The GKE master authorized network config cidr block dispaly name
        """
        pulumi.set(__self__, "cidr_block", cidr_block)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> pulumi.Input[str]:
        """
        The GKE master authorized network config cidr block
        """
        return pulumi.get(self, "cidr_block")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE master authorized network config cidr block dispaly name
        """
        return pulumi.get(self, "display_name")

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


@pulumi.input_type
class ClusterGkeConfigV2NodePoolArgs:
    def __init__(__self__, *,
                 initial_node_count: pulumi.Input[int],
                 name: pulumi.Input[str],
                 version: pulumi.Input[str],
                 autoscaling: Optional[pulumi.Input['ClusterGkeConfigV2NodePoolAutoscalingArgs']] = None,
                 config: Optional[pulumi.Input['ClusterGkeConfigV2NodePoolConfigArgs']] = None,
                 management: Optional[pulumi.Input['ClusterGkeConfigV2NodePoolManagementArgs']] = None,
                 max_pods_constraint: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] initial_node_count: The GKE node pool config initial node count
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[str] version: The GKE node pool config version
        :param pulumi.Input['ClusterGkeConfigV2NodePoolAutoscalingArgs'] autoscaling: The GKE node pool config autoscaling
        :param pulumi.Input['ClusterGkeConfigV2NodePoolConfigArgs'] config: The GKE node pool node config
        :param pulumi.Input['ClusterGkeConfigV2NodePoolManagementArgs'] management: The GKE node pool config management
        :param pulumi.Input[int] max_pods_constraint: The GKE node pool config max pods constraint
        """
        pulumi.set(__self__, "initial_node_count", initial_node_count)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, "max_pods_constraint", max_pods_constraint)

    @property
    @pulumi.getter(name="initialNodeCount")
    def initial_node_count(self) -> pulumi.Input[int]:
        """
        The GKE node pool config initial node count
        """
        return pulumi.get(self, "initial_node_count")

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

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

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

    @property
    @pulumi.getter
    def version(self) -> pulumi.Input[str]:
        """
        The GKE node pool config version
        """
        return pulumi.get(self, "version")

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

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional[pulumi.Input['ClusterGkeConfigV2NodePoolAutoscalingArgs']]:
        """
        The GKE node pool config autoscaling
        """
        return pulumi.get(self, "autoscaling")

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

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input['ClusterGkeConfigV2NodePoolConfigArgs']]:
        """
        The GKE node pool node config
        """
        return pulumi.get(self, "config")

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

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['ClusterGkeConfigV2NodePoolManagementArgs']]:
        """
        The GKE node pool config management
        """
        return pulumi.get(self, "management")

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

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> Optional[pulumi.Input[int]]:
        """
        The GKE node pool config max pods constraint
        """
        return pulumi.get(self, "max_pods_constraint")

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


@pulumi.input_type
class ClusterGkeConfigV2NodePoolAutoscalingArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 max_node_count: Optional[pulumi.Input[int]] = None,
                 min_node_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enabled: Enable GKE node pool config autoscaling
        :param pulumi.Input[int] max_node_count: The GKE node pool config max node count
        :param pulumi.Input[int] min_node_count: The GKE node pool config min node count
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        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)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE node pool config autoscaling
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        The GKE node pool config max node count
        """
        return pulumi.get(self, "max_node_count")

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

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        The GKE node pool config min node count
        """
        return pulumi.get(self, "min_node_count")

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


@pulumi.input_type
class ClusterGkeConfigV2NodePoolConfigArgs:
    def __init__(__self__, *,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 disk_type: Optional[pulumi.Input[str]] = None,
                 image_type: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 local_ssd_count: Optional[pulumi.Input[int]] = None,
                 machine_type: Optional[pulumi.Input[str]] = None,
                 oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 taints: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolConfigTaintArgs']]]] = None):
        """
        :param pulumi.Input[int] disk_size_gb: The GKE node config disk size (Gb)
        :param pulumi.Input[str] disk_type: The GKE node config disk type
        :param pulumi.Input[str] image_type: The GKE node config image type
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster (map)
        :param pulumi.Input[int] local_ssd_count: The GKE node config local ssd count
        :param pulumi.Input[str] machine_type: The GKE node config machine type
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The GKE node config oauth scopes
        :param pulumi.Input[bool] preemptible: Enable GKE node config preemptible
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The GKE node config tags
        :param pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolConfigTaintArgs']]] taints: The GKE node config taints
        """
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        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 machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        The GKE node config disk size (Gb)
        """
        return pulumi.get(self, "disk_size_gb")

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

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE node config disk type
        """
        return pulumi.get(self, "disk_type")

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

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE node config image type
        """
        return pulumi.get(self, "image_type")

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster (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[int]]:
        """
        The GKE node config local ssd count
        """
        return pulumi.get(self, "local_ssd_count")

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

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[pulumi.Input[str]]:
        """
        The GKE node config machine type
        """
        return pulumi.get(self, "machine_type")

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

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The GKE node config oauth scopes
        """
        return pulumi.get(self, "oauth_scopes")

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

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE node config preemptible
        """
        return pulumi.get(self, "preemptible")

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

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The GKE node config tags
        """
        return pulumi.get(self, "tags")

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

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolConfigTaintArgs']]]]:
        """
        The GKE node config taints
        """
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterGkeConfigV2NodePoolConfigTaintArgs']]]]):
        pulumi.set(self, "taints", value)


@pulumi.input_type
class ClusterGkeConfigV2NodePoolConfigTaintArgs:
    def __init__(__self__, *,
                 effect: pulumi.Input[str],
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        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]:
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ClusterGkeConfigV2NodePoolManagementArgs:
    def __init__(__self__, *,
                 auto_repair: Optional[pulumi.Input[bool]] = None,
                 auto_upgrade: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] auto_repair: Enable GKE node pool config management auto repair
        :param pulumi.Input[bool] auto_upgrade: Enable GKE node pool config management auto upgrade
        """
        if auto_repair is not None:
            pulumi.set(__self__, "auto_repair", auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, "auto_upgrade", auto_upgrade)

    @property
    @pulumi.getter(name="autoRepair")
    def auto_repair(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE node pool config management auto repair
        """
        return pulumi.get(self, "auto_repair")

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

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE node pool config management auto upgrade
        """
        return pulumi.get(self, "auto_upgrade")

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


@pulumi.input_type
class ClusterGkeConfigV2PrivateClusterConfigArgs:
    def __init__(__self__, *,
                 master_ipv4_cidr_block: pulumi.Input[str],
                 enable_private_endpoint: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block
        :param pulumi.Input[bool] enable_private_endpoint: Enable GKE cluster private endpoint
        :param pulumi.Input[bool] enable_private_nodes: Enable GKE cluster private nodes
        """
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        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)

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> pulumi.Input[str]:
        """
        The GKE cluster private master ip v4 cidr block
        """
        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="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable GKE cluster private endpoint
        """
        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]]:
        """
        Enable GKE cluster private nodes
        """
        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)


@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: The K3S upgrade strategy
        :param pulumi.Input[str] version: The K3S kubernetes version
        """
        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']]:
        """
        The K3S upgrade strategy
        """
        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]]:
        """
        The K3S kubernetes version
        """
        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[int]] = None,
                 worker_concurrency: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] drain_server_nodes: Drain server nodes
        :param pulumi.Input[bool] drain_worker_nodes: Drain worker nodes
        :param pulumi.Input[int] server_concurrency: Server concurrency
        :param pulumi.Input[int] worker_concurrency: Worker concurrency
        """
        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
        """
        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
        """
        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[int]]:
        """
        Server concurrency
        """
        return pulumi.get(self, "server_concurrency")

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

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

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


@pulumi.input_type
class ClusterOkeConfigArgs:
    def __init__(__self__, *,
                 compartment_id: pulumi.Input[str],
                 fingerprint: pulumi.Input[str],
                 kubernetes_version: pulumi.Input[str],
                 node_image: pulumi.Input[str],
                 node_shape: pulumi.Input[str],
                 private_key_contents: pulumi.Input[str],
                 region: pulumi.Input[str],
                 tenancy_id: pulumi.Input[str],
                 user_ocid: pulumi.Input[str],
                 custom_boot_volume_size: Optional[pulumi.Input[int]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 enable_kubernetes_dashboard: Optional[pulumi.Input[bool]] = None,
                 enable_private_control_plane: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None,
                 flex_ocpus: Optional[pulumi.Input[int]] = None,
                 kms_key_id: Optional[pulumi.Input[str]] = None,
                 limit_node_count: Optional[pulumi.Input[int]] = None,
                 load_balancer_subnet_name1: Optional[pulumi.Input[str]] = None,
                 load_balancer_subnet_name2: Optional[pulumi.Input[str]] = None,
                 node_pool_dns_domain_name: Optional[pulumi.Input[str]] = None,
                 node_pool_subnet_name: Optional[pulumi.Input[str]] = None,
                 node_public_key_contents: Optional[pulumi.Input[str]] = None,
                 pod_cidr: Optional[pulumi.Input[str]] = None,
                 private_key_passphrase: Optional[pulumi.Input[str]] = None,
                 quantity_of_node_subnets: Optional[pulumi.Input[int]] = None,
                 quantity_per_subnet: Optional[pulumi.Input[int]] = None,
                 service_cidr: Optional[pulumi.Input[str]] = None,
                 service_dns_domain_name: Optional[pulumi.Input[str]] = None,
                 skip_vcn_delete: Optional[pulumi.Input[bool]] = None,
                 vcn_compartment_id: Optional[pulumi.Input[str]] = None,
                 vcn_name: Optional[pulumi.Input[str]] = None,
                 worker_node_ingress_cidr: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] compartment_id: The OCID of the compartment in which to create resources (VCN, worker nodes, etc.)
        :param pulumi.Input[str] fingerprint: The fingerprint corresponding to the specified user's private API Key
        :param pulumi.Input[str] kubernetes_version: The Kubernetes version that will be used for your master *and* worker nodes e.g. v1.19.7
        :param pulumi.Input[str] node_image: The OS for the node image
        :param pulumi.Input[str] node_shape: The shape of the node (determines number of CPUs and  amount of memory on each node)
        :param pulumi.Input[str] private_key_contents: The private API key file contents for the specified user, in PEM format
        :param pulumi.Input[str] region: The availability domain within the region to host the OKE cluster
        :param pulumi.Input[str] tenancy_id: The OCID of the tenancy in which to create resources
        :param pulumi.Input[str] user_ocid: The OCID of a user who has access to the tenancy/compartment
        :param pulumi.Input[int] custom_boot_volume_size: An optional custom boot volume size (in GB) for the nodes
        :param pulumi.Input[str] description: The description for Cluster (string)
        :param pulumi.Input[bool] enable_kubernetes_dashboard: Enable the kubernetes dashboard
        :param pulumi.Input[bool] enable_private_control_plane: Whether Kubernetes API endpoint is a private IP only accessible from within the VCN
        :param pulumi.Input[bool] enable_private_nodes: Whether worker nodes are deployed into a new private subnet
        :param pulumi.Input[int] flex_ocpus: Optional number of OCPUs for nodes (requires flexible node_shape)
        :param pulumi.Input[str] kms_key_id: Optional specify the OCID of the KMS Vault master key
        :param pulumi.Input[int] limit_node_count: Optional limit on the total number of nodes in the pool
        :param pulumi.Input[str] load_balancer_subnet_name1: The name of the first existing subnet to use for Kubernetes services / LB
        :param pulumi.Input[str] load_balancer_subnet_name2: The (optional) name of a second existing subnet to use for Kubernetes services / LB
        :param pulumi.Input[str] node_pool_dns_domain_name: Optional name for DNS domain of node pool subnet
        :param pulumi.Input[str] node_pool_subnet_name: Optional name for node pool subnet
        :param pulumi.Input[str] node_public_key_contents: The contents of the SSH public key file to use for the nodes
        :param pulumi.Input[str] pod_cidr: Optional specify the pod CIDR, defaults to 10.244.0.0/16
        :param pulumi.Input[str] private_key_passphrase: The passphrase of the private key for the OKE cluster
        :param pulumi.Input[int] quantity_of_node_subnets: Number of node subnets (defaults to creating 1 regional subnet)
        :param pulumi.Input[int] quantity_per_subnet: Number of worker nodes in each subnet / availability domain
        :param pulumi.Input[str] service_cidr: Optional specify the service CIDR, defaults to 10.96.0.0/16
        :param pulumi.Input[str] service_dns_domain_name: Optional name for DNS domain of service subnet
        :param pulumi.Input[bool] skip_vcn_delete: Whether to skip deleting VCN
        :param pulumi.Input[str] vcn_compartment_id: The OCID of the compartment (if different from compartment_id) in which to find the pre-existing virtual network set with vcn_name.
        :param pulumi.Input[str] vcn_name: The optional name of an existing virtual network to use for the cluster creation. A new VCN will be created if not specified.
        :param pulumi.Input[str] worker_node_ingress_cidr: Additional CIDR from which to allow ingress to worker nodes
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "fingerprint", fingerprint)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "node_image", node_image)
        pulumi.set(__self__, "node_shape", node_shape)
        pulumi.set(__self__, "private_key_contents", private_key_contents)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenancy_id", tenancy_id)
        pulumi.set(__self__, "user_ocid", user_ocid)
        if custom_boot_volume_size is not None:
            pulumi.set(__self__, "custom_boot_volume_size", custom_boot_volume_size)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_dashboard is not None:
            pulumi.set(__self__, "enable_kubernetes_dashboard", enable_kubernetes_dashboard)
        if enable_private_control_plane is not None:
            pulumi.set(__self__, "enable_private_control_plane", enable_private_control_plane)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if flex_ocpus is not None:
            pulumi.set(__self__, "flex_ocpus", flex_ocpus)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if limit_node_count is not None:
            pulumi.set(__self__, "limit_node_count", limit_node_count)
        if load_balancer_subnet_name1 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name1", load_balancer_subnet_name1)
        if load_balancer_subnet_name2 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name2", load_balancer_subnet_name2)
        if node_pool_dns_domain_name is not None:
            pulumi.set(__self__, "node_pool_dns_domain_name", node_pool_dns_domain_name)
        if node_pool_subnet_name is not None:
            pulumi.set(__self__, "node_pool_subnet_name", node_pool_subnet_name)
        if node_public_key_contents is not None:
            pulumi.set(__self__, "node_public_key_contents", node_public_key_contents)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if private_key_passphrase is not None:
            pulumi.set(__self__, "private_key_passphrase", private_key_passphrase)
        if quantity_of_node_subnets is not None:
            pulumi.set(__self__, "quantity_of_node_subnets", quantity_of_node_subnets)
        if quantity_per_subnet is not None:
            pulumi.set(__self__, "quantity_per_subnet", quantity_per_subnet)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)
        if service_dns_domain_name is not None:
            pulumi.set(__self__, "service_dns_domain_name", service_dns_domain_name)
        if skip_vcn_delete is not None:
            pulumi.set(__self__, "skip_vcn_delete", skip_vcn_delete)
        if vcn_compartment_id is not None:
            pulumi.set(__self__, "vcn_compartment_id", vcn_compartment_id)
        if vcn_name is not None:
            pulumi.set(__self__, "vcn_name", vcn_name)
        if worker_node_ingress_cidr is not None:
            pulumi.set(__self__, "worker_node_ingress_cidr", worker_node_ingress_cidr)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> pulumi.Input[str]:
        """
        The OCID of the compartment in which to create resources (VCN, worker nodes, etc.)
        """
        return pulumi.get(self, "compartment_id")

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

    @property
    @pulumi.getter
    def fingerprint(self) -> pulumi.Input[str]:
        """
        The fingerprint corresponding to the specified user's private API Key
        """
        return pulumi.get(self, "fingerprint")

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> pulumi.Input[str]:
        """
        The Kubernetes version that will be used for your master *and* worker nodes e.g. v1.19.7
        """
        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="nodeImage")
    def node_image(self) -> pulumi.Input[str]:
        """
        The OS for the node image
        """
        return pulumi.get(self, "node_image")

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

    @property
    @pulumi.getter(name="nodeShape")
    def node_shape(self) -> pulumi.Input[str]:
        """
        The shape of the node (determines number of CPUs and  amount of memory on each node)
        """
        return pulumi.get(self, "node_shape")

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

    @property
    @pulumi.getter(name="privateKeyContents")
    def private_key_contents(self) -> pulumi.Input[str]:
        """
        The private API key file contents for the specified user, in PEM format
        """
        return pulumi.get(self, "private_key_contents")

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

    @property
    @pulumi.getter
    def region(self) -> pulumi.Input[str]:
        """
        The availability domain within the region to host the OKE cluster
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="tenancyId")
    def tenancy_id(self) -> pulumi.Input[str]:
        """
        The OCID of the tenancy in which to create resources
        """
        return pulumi.get(self, "tenancy_id")

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

    @property
    @pulumi.getter(name="userOcid")
    def user_ocid(self) -> pulumi.Input[str]:
        """
        The OCID of a user who has access to the tenancy/compartment
        """
        return pulumi.get(self, "user_ocid")

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

    @property
    @pulumi.getter(name="customBootVolumeSize")
    def custom_boot_volume_size(self) -> Optional[pulumi.Input[int]]:
        """
        An optional custom boot volume size (in GB) for the nodes
        """
        return pulumi.get(self, "custom_boot_volume_size")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        The description for 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="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable the kubernetes dashboard
        """
        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="enablePrivateControlPlane")
    def enable_private_control_plane(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Kubernetes API endpoint is a private IP only accessible from within the VCN
        """
        return pulumi.get(self, "enable_private_control_plane")

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

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether worker nodes are deployed into a new private subnet
        """
        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="flexOcpus")
    def flex_ocpus(self) -> Optional[pulumi.Input[int]]:
        """
        Optional number of OCPUs for nodes (requires flexible node_shape)
        """
        return pulumi.get(self, "flex_ocpus")

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

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        Optional specify the OCID of the KMS Vault master key
        """
        return pulumi.get(self, "kms_key_id")

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

    @property
    @pulumi.getter(name="limitNodeCount")
    def limit_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Optional limit on the total number of nodes in the pool
        """
        return pulumi.get(self, "limit_node_count")

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

    @property
    @pulumi.getter(name="loadBalancerSubnetName1")
    def load_balancer_subnet_name1(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the first existing subnet to use for Kubernetes services / LB
        """
        return pulumi.get(self, "load_balancer_subnet_name1")

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

    @property
    @pulumi.getter(name="loadBalancerSubnetName2")
    def load_balancer_subnet_name2(self) -> Optional[pulumi.Input[str]]:
        """
        The (optional) name of a second existing subnet to use for Kubernetes services / LB
        """
        return pulumi.get(self, "load_balancer_subnet_name2")

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

    @property
    @pulumi.getter(name="nodePoolDnsDomainName")
    def node_pool_dns_domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        Optional name for DNS domain of node pool subnet
        """
        return pulumi.get(self, "node_pool_dns_domain_name")

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

    @property
    @pulumi.getter(name="nodePoolSubnetName")
    def node_pool_subnet_name(self) -> Optional[pulumi.Input[str]]:
        """
        Optional name for node pool subnet
        """
        return pulumi.get(self, "node_pool_subnet_name")

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

    @property
    @pulumi.getter(name="nodePublicKeyContents")
    def node_public_key_contents(self) -> Optional[pulumi.Input[str]]:
        """
        The contents of the SSH public key file to use for the nodes
        """
        return pulumi.get(self, "node_public_key_contents")

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

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        Optional specify the pod CIDR, defaults to 10.244.0.0/16
        """
        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="privateKeyPassphrase")
    def private_key_passphrase(self) -> Optional[pulumi.Input[str]]:
        """
        The passphrase of the private key for the OKE cluster
        """
        return pulumi.get(self, "private_key_passphrase")

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

    @property
    @pulumi.getter(name="quantityOfNodeSubnets")
    def quantity_of_node_subnets(self) -> Optional[pulumi.Input[int]]:
        """
        Number of node subnets (defaults to creating 1 regional subnet)
        """
        return pulumi.get(self, "quantity_of_node_subnets")

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

    @property
    @pulumi.getter(name="quantityPerSubnet")
    def quantity_per_subnet(self) -> Optional[pulumi.Input[int]]:
        """
        Number of worker nodes in each subnet / availability domain
        """
        return pulumi.get(self, "quantity_per_subnet")

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

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        Optional specify the service CIDR, defaults to 10.96.0.0/16
        """
        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(name="serviceDnsDomainName")
    def service_dns_domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        Optional name for DNS domain of service subnet
        """
        return pulumi.get(self, "service_dns_domain_name")

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

    @property
    @pulumi.getter(name="skipVcnDelete")
    def skip_vcn_delete(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to skip deleting VCN
        """
        return pulumi.get(self, "skip_vcn_delete")

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

    @property
    @pulumi.getter(name="vcnCompartmentId")
    def vcn_compartment_id(self) -> Optional[pulumi.Input[str]]:
        """
        The OCID of the compartment (if different from compartment_id) in which to find the pre-existing virtual network set with vcn_name.
        """
        return pulumi.get(self, "vcn_compartment_id")

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

    @property
    @pulumi.getter(name="vcnName")
    def vcn_name(self) -> Optional[pulumi.Input[str]]:
        """
        The optional name of an existing virtual network to use for the cluster creation. A new VCN will be created if not specified.
        """
        return pulumi.get(self, "vcn_name")

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

    @property
    @pulumi.getter(name="workerNodeIngressCidr")
    def worker_node_ingress_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        Additional CIDR from which to allow ingress to worker nodes
        """
        return pulumi.get(self, "worker_node_ingress_cidr")

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


@pulumi.input_type
class ClusterRke2ConfigArgs:
    def __init__(__self__, *,
                 upgrade_strategy: Optional[pulumi.Input['ClusterRke2ConfigUpgradeStrategyArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterRke2ConfigUpgradeStrategyArgs'] upgrade_strategy: The RKE2 upgrade strategy
        :param pulumi.Input[str] version: The RKE2 kubernetes version
        """
        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['ClusterRke2ConfigUpgradeStrategyArgs']]:
        """
        The RKE2 upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

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

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

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


@pulumi.input_type
class ClusterRke2ConfigUpgradeStrategyArgs:
    def __init__(__self__, *,
                 drain_server_nodes: Optional[pulumi.Input[bool]] = None,
                 drain_worker_nodes: Optional[pulumi.Input[bool]] = None,
                 server_concurrency: Optional[pulumi.Input[int]] = None,
                 worker_concurrency: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] drain_server_nodes: Drain server nodes
        :param pulumi.Input[bool] drain_worker_nodes: Drain worker nodes
        :param pulumi.Input[int] server_concurrency: Server concurrency
        :param pulumi.Input[int] worker_concurrency: Worker concurrency
        """
        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
        """
        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
        """
        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[int]]:
        """
        Server concurrency
        """
        return pulumi.get(self, "server_concurrency")

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

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

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


@pulumi.input_type
class ClusterRkeConfigArgs:
    def __init__(__self__, *,
                 addon_job_timeout: Optional[pulumi.Input[int]] = None,
                 addons: Optional[pulumi.Input[str]] = None,
                 addons_includes: Optional[pulumi.Input[Sequence[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,
                 enable_cri_dockerd: Optional[pulumi.Input[bool]] = 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[Sequence[pulumi.Input['ClusterRkeConfigNodeArgs']]]] = None,
                 prefix_path: Optional[pulumi.Input[str]] = None,
                 private_registries: Optional[pulumi.Input[Sequence[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,
                 win_prefix_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] addon_job_timeout: Optional duration in seconds of addon job.
        :param pulumi.Input[str] addons: Optional addons descripton to deploy on rke cluster.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param pulumi.Input['ClusterRkeConfigAuthenticationArgs'] authentication: Kubernetes cluster authentication
        :param pulumi.Input['ClusterRkeConfigAuthorizationArgs'] authorization: Kubernetes cluster authorization
        :param pulumi.Input['ClusterRkeConfigBastionHostArgs'] bastion_host: RKE bastion host
        :param pulumi.Input[bool] enable_cri_dockerd: Enable/disable using cri-dockerd
        :param pulumi.Input[bool] ignore_docker_version: Optional ignore docker version on nodes
        :param pulumi.Input['ClusterRkeConfigIngressArgs'] ingress: Kubernetes ingress configuration
        :param pulumi.Input[str] kubernetes_version: Optional kubernetes version to deploy
        :param pulumi.Input['ClusterRkeConfigMonitoringArgs'] monitoring: Kubernetes cluster monitoring
        :param pulumi.Input['ClusterRkeConfigNetworkArgs'] network: Kubernetes cluster networking
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigNodeArgs']]] nodes: Optional RKE cluster nodes
        :param pulumi.Input[str] prefix_path: Optional prefix to customize kubernetes path
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigPrivateRegistryArgs']]] private_registries: Optional private registries for docker images
        :param pulumi.Input['ClusterRkeConfigServicesArgs'] services: Kubernetes cluster services
        :param pulumi.Input[bool] ssh_agent_auth: Optional use ssh agent auth
        :param pulumi.Input[str] ssh_cert_path: Optional cluster level SSH certificate path
        :param pulumi.Input[str] ssh_key_path: Optional cluster level SSH private key path
        :param pulumi.Input['ClusterRkeConfigUpgradeStrategyArgs'] upgrade_strategy: RKE upgrade strategy
        :param pulumi.Input[str] win_prefix_path: Optional prefix to customize kubernetes path for windows
        """
        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 enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        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)
        if win_prefix_path is not None:
            pulumi.set(__self__, "win_prefix_path", win_prefix_path)

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

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

    @property
    @pulumi.getter
    def addons(self) -> Optional[pulumi.Input[str]]:
        """
        Optional 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[Sequence[pulumi.Input[str]]]]:
        """
        Optional addons yaml manisfest to deploy on rke cluster.
        """
        return pulumi.get(self, "addons_includes")

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

    @property
    @pulumi.getter
    def authentication(self) -> Optional[pulumi.Input['ClusterRkeConfigAuthenticationArgs']]:
        """
        Kubernetes cluster authentication
        """
        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
        """
        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
        """
        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']]:
        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']]:
        return pulumi.get(self, "dns")

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

    @property
    @pulumi.getter(name="enableCriDockerd")
    def enable_cri_dockerd(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

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

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[pulumi.Input[bool]]:
        """
        Optional ignore docker version on nodes
        """
        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
        """
        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]]:
        """
        Optional kubernetes version to deploy
        """
        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
        """
        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']]:
        """
        Kubernetes cluster networking
        """
        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[Sequence[pulumi.Input['ClusterRkeConfigNodeArgs']]]]:
        """
        Optional RKE cluster nodes
        """
        return pulumi.get(self, "nodes")

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

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> Optional[pulumi.Input[str]]:
        """
        Optional prefix to customize kubernetes path
        """
        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[Sequence[pulumi.Input['ClusterRkeConfigPrivateRegistryArgs']]]]:
        """
        Optional private registries for docker images
        """
        return pulumi.get(self, "private_registries")

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

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesArgs']]:
        """
        Kubernetes cluster services
        """
        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]]:
        """
        Optional use ssh agent auth
        """
        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]]:
        """
        Optional cluster level SSH certificate path
        """
        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]]:
        """
        Optional cluster level SSH private key path
        """
        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']]:
        """
        RKE upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

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

    @property
    @pulumi.getter(name="winPrefixPath")
    def win_prefix_path(self) -> Optional[pulumi.Input[str]]:
        """
        Optional prefix to customize kubernetes path for windows
        """
        return pulumi.get(self, "win_prefix_path")

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


@pulumi.input_type
class ClusterRkeConfigAuthenticationArgs:
    def __init__(__self__, *,
                 sans: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "sans")

    @sans.setter
    def sans(self, value: Optional[pulumi.Input[Sequence[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 ClusterRkeConfigAuthorizationArgs:
    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 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):
        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 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[str] name: The name of the Cluster (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['ClusterRkeConfigCloudProviderAwsCloudProviderArgs']]:
        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']]:
        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]]:
        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 name of the Cluster (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']]:
        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']]:
        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[Sequence[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]] = 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['ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs']]:
        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[Sequence[pulumi.Input['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]]:
        return pulumi.get(self, "service_overrides")

    @service_overrides.setter
    def service_overrides(self, value: Optional[pulumi.Input[Sequence[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):
        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 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):
        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 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[int]] = None,
                 cloud_provider_backoff_exponent: Optional[pulumi.Input[int]] = None,
                 cloud_provider_backoff_jitter: Optional[pulumi.Input[int]] = None,
                 cloud_provider_backoff_retries: Optional[pulumi.Input[int]] = None,
                 cloud_provider_rate_limit: Optional[pulumi.Input[bool]] = None,
                 cloud_provider_rate_limit_bucket: Optional[pulumi.Input[int]] = None,
                 cloud_provider_rate_limit_qps: Optional[pulumi.Input[int]] = None,
                 load_balancer_sku: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 maximum_load_balancer_rule_count: Optional[pulumi.Input[int]] = 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] load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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[int]]:
        return pulumi.get(self, "cloud_provider_backoff_duration")

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

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

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

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

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

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

    @cloud_provider_backoff_retries.setter
    def cloud_provider_backoff_retries(self, value: Optional[pulumi.Input[int]]):
        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[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[int]]):
        pulumi.set(self, "cloud_provider_rate_limit_bucket", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> Optional[pulumi.Input[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[int]]):
        pulumi.set(self, "cloud_provider_rate_limit_qps", value)

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[pulumi.Input[str]]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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[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[int]]):
        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 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):
        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']:
        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']]:
        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']]:
        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']]:
        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']]:
        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):
        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 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):
        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 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[int]] = 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[int]]:
        return pulumi.get(self, "monitor_max_retries")

    @monitor_max_retries.setter
    def monitor_max_retries(self, value: Optional[pulumi.Input[int]]):
        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 ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs:
    def __init__(__self__, *,
                 request_timeout: Optional[pulumi.Input[int]] = 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[int]]:
        return pulumi.get(self, "request_timeout")

    @request_timeout.setter
    def request_timeout(self, value: Optional[pulumi.Input[int]]):
        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 ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs:
    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 ClusterRkeConfigCloudProviderVsphereCloudProviderArgs:
    def __init__(__self__, *,
                 virtual_centers: pulumi.Input[Sequence[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):
        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[Sequence[pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]]:
        return pulumi.get(self, "virtual_centers")

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

    @property
    @pulumi.getter
    def workspace(self) -> pulumi.Input['ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs']:
        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']]:
        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']]:
        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']]:
        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):
        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 ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs:
    def __init__(__self__, *,
                 datacenters: Optional[pulumi.Input[str]] = None,
                 graceful_shutdown_timeout: 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[int]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        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="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "graceful_shutdown_timeout")

    @graceful_shutdown_timeout.setter
    def graceful_shutdown_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "graceful_shutdown_timeout", 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[int]]:
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[int]]):
        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 ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs:
    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 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[int]] = None):
        """
        :param pulumi.Input[str] name: The name of the Cluster (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 name of the Cluster (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[int]]:
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[int]]):
        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):
        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 ClusterRkeConfigDnsArgs:
    def __init__(__self__, *,
                 linear_autoscaler_params: Optional[pulumi.Input['ClusterRkeConfigDnsLinearAutoscalerParamsArgs']] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 nodelocal: Optional[pulumi.Input['ClusterRkeConfigDnsNodelocalArgs']] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 reverse_cidrs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigDnsTolerationArgs']]]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterRkeConfigDnsUpdateStrategyArgs']] = None,
                 upstream_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigDnsLinearAutoscalerParamsArgs'] linear_autoscaler_params: Linear Autoscaler Params
        :param pulumi.Input['ClusterRkeConfigDnsNodelocalArgs'] nodelocal: Nodelocal dns
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigDnsTolerationArgs']]] tolerations: DNS service tolerations
        :param pulumi.Input['ClusterRkeConfigDnsUpdateStrategyArgs'] update_strategy: Update deployment strategy
        """
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional[pulumi.Input['ClusterRkeConfigDnsLinearAutoscalerParamsArgs']]:
        """
        Linear Autoscaler Params
        """
        return pulumi.get(self, "linear_autoscaler_params")

    @linear_autoscaler_params.setter
    def linear_autoscaler_params(self, value: Optional[pulumi.Input['ClusterRkeConfigDnsLinearAutoscalerParamsArgs']]):
        pulumi.set(self, "linear_autoscaler_params", 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 nodelocal(self) -> Optional[pulumi.Input['ClusterRkeConfigDnsNodelocalArgs']]:
        """
        Nodelocal dns
        """
        return pulumi.get(self, "nodelocal")

    @nodelocal.setter
    def nodelocal(self, value: Optional[pulumi.Input['ClusterRkeConfigDnsNodelocalArgs']]):
        pulumi.set(self, "nodelocal", 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(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "reverse_cidrs")

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigDnsTolerationArgs']]]]:
        """
        DNS service tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigDnsTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterRkeConfigDnsUpdateStrategyArgs']]:
        """
        Update deployment strategy
        """
        return pulumi.get(self, "update_strategy")

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

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

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


@pulumi.input_type
class ClusterRkeConfigDnsLinearAutoscalerParamsArgs:
    def __init__(__self__, *,
                 cores_per_replica: Optional[pulumi.Input[float]] = None,
                 max: Optional[pulumi.Input[int]] = None,
                 min: Optional[pulumi.Input[int]] = None,
                 nodes_per_replica: Optional[pulumi.Input[float]] = None,
                 prevent_single_point_failure: Optional[pulumi.Input[bool]] = None):
        if cores_per_replica is not None:
            pulumi.set(__self__, "cores_per_replica", cores_per_replica)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)
        if nodes_per_replica is not None:
            pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
        if prevent_single_point_failure is not None:
            pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)

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

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

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

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

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

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

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

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

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

    @prevent_single_point_failure.setter
    def prevent_single_point_failure(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prevent_single_point_failure", 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[Mapping[str, Any]] node_selector: Node selector key pair
        """
        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]]]:
        """
        Node selector key pair
        """
        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 ClusterRkeConfigDnsTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterRkeConfigDnsUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs'] rolling_update: Rolling update for update strategy
        :param pulumi.Input[str] strategy: Strategy
        """
        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['ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs']]:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

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

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

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


@pulumi.input_type
class ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_surge: Optional[pulumi.Input[int]] = None,
                 max_unavailable: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_surge: Rolling update max surge
        :param pulumi.Input[int] max_unavailable: Rolling update max unavailable
        """
        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[int]]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

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

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

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


@pulumi.input_type
class ClusterRkeConfigIngressArgs:
    def __init__(__self__, *,
                 default_backend: Optional[pulumi.Input[bool]] = None,
                 dns_policy: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 http_port: Optional[pulumi.Input[int]] = None,
                 https_port: Optional[pulumi.Input[int]] = None,
                 network_mode: Optional[pulumi.Input[str]] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigIngressTolerationArgs']]]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterRkeConfigIngressUpdateStrategyArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigIngressTolerationArgs']]] tolerations: Ingress add-on tolerations
        :param pulumi.Input['ClusterRkeConfigIngressUpdateStrategyArgs'] update_strategy: Update daemon set strategy
        """
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        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 http_port is not None:
            pulumi.set(__self__, "http_port", http_port)
        if https_port is not None:
            pulumi.set(__self__, "https_port", https_port)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

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

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

    @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="httpPort")
    def http_port(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "http_port")

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

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

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

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

    @network_mode.setter
    def network_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_mode", 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)

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigIngressTolerationArgs']]]]:
        """
        Ingress add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigIngressTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterRkeConfigIngressUpdateStrategyArgs']]:
        """
        Update daemon set strategy
        """
        return pulumi.get(self, "update_strategy")

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


@pulumi.input_type
class ClusterRkeConfigIngressTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterRkeConfigIngressUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs'] rolling_update: Rolling update for update strategy
        :param pulumi.Input[str] strategy: Strategy
        """
        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['ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs']]:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

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

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

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


@pulumi.input_type
class ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_unavailable: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_unavailable: Rolling update max unavailable
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable", 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[int]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigMonitoringTolerationArgs']]]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigMonitoringTolerationArgs']]] tolerations: Monitoring add-on tolerations
        :param pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs'] update_strategy: Update deployment strategy
        """
        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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        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[int]]:
        return pulumi.get(self, "replicas")

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigMonitoringTolerationArgs']]]]:
        """
        Monitoring add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigMonitoringTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterRkeConfigMonitoringUpdateStrategyArgs']]:
        """
        Update deployment strategy
        """
        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 ClusterRkeConfigMonitoringTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", 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: Rolling update for update strategy
        :param pulumi.Input[str] strategy: Strategy
        """
        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']]:
        """
        Rolling update for update strategy
        """
        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]]:
        """
        Strategy
        """
        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[int]] = None,
                 max_unavailable: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_surge: Rolling update max surge
        :param pulumi.Input[int] max_unavailable: Rolling update max unavailable
        """
        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[int]]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

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

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

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


@pulumi.input_type
class ClusterRkeConfigNetworkArgs:
    def __init__(__self__, *,
                 aci_network_provider: Optional[pulumi.Input['ClusterRkeConfigNetworkAciNetworkProviderArgs']] = None,
                 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[int]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 plugin: Optional[pulumi.Input[str]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigNetworkTolerationArgs']]]] = None,
                 weave_network_provider: Optional[pulumi.Input['ClusterRkeConfigNetworkWeaveNetworkProviderArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigNetworkTolerationArgs']]] tolerations: Network add-on tolerations
        """
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="aciNetworkProvider")
    def aci_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkAciNetworkProviderArgs']]:
        return pulumi.get(self, "aci_network_provider")

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

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkCalicoNetworkProviderArgs']]:
        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']]:
        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']]:
        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[int]]:
        return pulumi.get(self, "mtu")

    @mtu.setter
    def mtu(self, value: Optional[pulumi.Input[int]]):
        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
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigNetworkTolerationArgs']]]]:
        """
        Network add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigNetworkTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional[pulumi.Input['ClusterRkeConfigNetworkWeaveNetworkProviderArgs']]:
        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 ClusterRkeConfigNetworkAciNetworkProviderArgs:
    def __init__(__self__, *,
                 aep: pulumi.Input[str],
                 apic_hosts: pulumi.Input[Sequence[pulumi.Input[str]]],
                 apic_user_crt: pulumi.Input[str],
                 apic_user_key: pulumi.Input[str],
                 apic_user_name: pulumi.Input[str],
                 encap_type: pulumi.Input[str],
                 extern_dynamic: pulumi.Input[str],
                 extern_static: pulumi.Input[str],
                 kube_api_vlan: pulumi.Input[str],
                 l3out: pulumi.Input[str],
                 l3out_external_networks: pulumi.Input[Sequence[pulumi.Input[str]]],
                 mcast_range_end: pulumi.Input[str],
                 mcast_range_start: pulumi.Input[str],
                 node_subnet: pulumi.Input[str],
                 node_svc_subnet: pulumi.Input[str],
                 service_vlan: pulumi.Input[str],
                 system_id: pulumi.Input[str],
                 token: pulumi.Input[str],
                 vrf_name: pulumi.Input[str],
                 vrf_tenant: pulumi.Input[str],
                 apic_refresh_ticker_adjust: Optional[pulumi.Input[str]] = None,
                 apic_refresh_time: Optional[pulumi.Input[str]] = None,
                 apic_subscription_delay: Optional[pulumi.Input[str]] = None,
                 capic: Optional[pulumi.Input[str]] = None,
                 controller_log_level: Optional[pulumi.Input[str]] = None,
                 disable_periodic_snat_global_info_sync: Optional[pulumi.Input[str]] = None,
                 disable_wait_for_network: Optional[pulumi.Input[str]] = None,
                 drop_log_enable: Optional[pulumi.Input[str]] = None,
                 duration_wait_for_network: Optional[pulumi.Input[str]] = None,
                 enable_endpoint_slice: Optional[pulumi.Input[str]] = None,
                 ep_registry: Optional[pulumi.Input[str]] = None,
                 gbp_pod_subnet: Optional[pulumi.Input[str]] = None,
                 host_agent_log_level: Optional[pulumi.Input[str]] = None,
                 image_pull_policy: Optional[pulumi.Input[str]] = None,
                 image_pull_secret: Optional[pulumi.Input[str]] = None,
                 infra_vlan: Optional[pulumi.Input[str]] = None,
                 install_istio: Optional[pulumi.Input[str]] = None,
                 istio_profile: Optional[pulumi.Input[str]] = None,
                 kafka_brokers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kafka_client_crt: Optional[pulumi.Input[str]] = None,
                 kafka_client_key: Optional[pulumi.Input[str]] = None,
                 max_nodes_svc_graph: Optional[pulumi.Input[str]] = None,
                 mtu_head_room: Optional[pulumi.Input[str]] = None,
                 multus_disable: Optional[pulumi.Input[str]] = None,
                 no_priority_class: Optional[pulumi.Input[str]] = None,
                 node_pod_if_enable: Optional[pulumi.Input[str]] = None,
                 opflex_client_ssl: Optional[pulumi.Input[str]] = None,
                 opflex_device_delete_timeout: Optional[pulumi.Input[str]] = None,
                 opflex_log_level: Optional[pulumi.Input[str]] = None,
                 opflex_mode: Optional[pulumi.Input[str]] = None,
                 opflex_server_port: Optional[pulumi.Input[str]] = None,
                 overlay_vrf_name: Optional[pulumi.Input[str]] = None,
                 ovs_memory_limit: Optional[pulumi.Input[str]] = None,
                 pbr_tracking_non_snat: Optional[pulumi.Input[str]] = None,
                 pod_subnet_chunk_size: Optional[pulumi.Input[str]] = None,
                 run_gbp_container: Optional[pulumi.Input[str]] = None,
                 run_opflex_server_container: Optional[pulumi.Input[str]] = None,
                 service_monitor_interval: Optional[pulumi.Input[str]] = None,
                 snat_contract_scope: Optional[pulumi.Input[str]] = None,
                 snat_namespace: Optional[pulumi.Input[str]] = None,
                 snat_port_range_end: Optional[pulumi.Input[str]] = None,
                 snat_port_range_start: Optional[pulumi.Input[str]] = None,
                 snat_ports_per_node: Optional[pulumi.Input[str]] = None,
                 sriov_enable: Optional[pulumi.Input[str]] = None,
                 subnet_domain_name: Optional[pulumi.Input[str]] = None,
                 tenant: Optional[pulumi.Input[str]] = None,
                 use_aci_anywhere_crd: Optional[pulumi.Input[str]] = None,
                 use_aci_cni_priority_class: Optional[pulumi.Input[str]] = None,
                 use_cluster_role: Optional[pulumi.Input[str]] = None,
                 use_host_netns_volume: Optional[pulumi.Input[str]] = None,
                 use_opflex_server_volume: Optional[pulumi.Input[str]] = None,
                 use_privileged_container: Optional[pulumi.Input[str]] = None,
                 vmm_controller: Optional[pulumi.Input[str]] = None,
                 vmm_domain: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "aep", aep)
        pulumi.set(__self__, "apic_hosts", apic_hosts)
        pulumi.set(__self__, "apic_user_crt", apic_user_crt)
        pulumi.set(__self__, "apic_user_key", apic_user_key)
        pulumi.set(__self__, "apic_user_name", apic_user_name)
        pulumi.set(__self__, "encap_type", encap_type)
        pulumi.set(__self__, "extern_dynamic", extern_dynamic)
        pulumi.set(__self__, "extern_static", extern_static)
        pulumi.set(__self__, "kube_api_vlan", kube_api_vlan)
        pulumi.set(__self__, "l3out", l3out)
        pulumi.set(__self__, "l3out_external_networks", l3out_external_networks)
        pulumi.set(__self__, "mcast_range_end", mcast_range_end)
        pulumi.set(__self__, "mcast_range_start", mcast_range_start)
        pulumi.set(__self__, "node_subnet", node_subnet)
        pulumi.set(__self__, "node_svc_subnet", node_svc_subnet)
        pulumi.set(__self__, "service_vlan", service_vlan)
        pulumi.set(__self__, "system_id", system_id)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "vrf_name", vrf_name)
        pulumi.set(__self__, "vrf_tenant", vrf_tenant)
        if apic_refresh_ticker_adjust is not None:
            pulumi.set(__self__, "apic_refresh_ticker_adjust", apic_refresh_ticker_adjust)
        if apic_refresh_time is not None:
            pulumi.set(__self__, "apic_refresh_time", apic_refresh_time)
        if apic_subscription_delay is not None:
            pulumi.set(__self__, "apic_subscription_delay", apic_subscription_delay)
        if capic is not None:
            pulumi.set(__self__, "capic", capic)
        if controller_log_level is not None:
            pulumi.set(__self__, "controller_log_level", controller_log_level)
        if disable_periodic_snat_global_info_sync is not None:
            pulumi.set(__self__, "disable_periodic_snat_global_info_sync", disable_periodic_snat_global_info_sync)
        if disable_wait_for_network is not None:
            pulumi.set(__self__, "disable_wait_for_network", disable_wait_for_network)
        if drop_log_enable is not None:
            pulumi.set(__self__, "drop_log_enable", drop_log_enable)
        if duration_wait_for_network is not None:
            pulumi.set(__self__, "duration_wait_for_network", duration_wait_for_network)
        if enable_endpoint_slice is not None:
            pulumi.set(__self__, "enable_endpoint_slice", enable_endpoint_slice)
        if ep_registry is not None:
            pulumi.set(__self__, "ep_registry", ep_registry)
        if gbp_pod_subnet is not None:
            pulumi.set(__self__, "gbp_pod_subnet", gbp_pod_subnet)
        if host_agent_log_level is not None:
            pulumi.set(__self__, "host_agent_log_level", host_agent_log_level)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if infra_vlan is not None:
            pulumi.set(__self__, "infra_vlan", infra_vlan)
        if install_istio is not None:
            pulumi.set(__self__, "install_istio", install_istio)
        if istio_profile is not None:
            pulumi.set(__self__, "istio_profile", istio_profile)
        if kafka_brokers is not None:
            pulumi.set(__self__, "kafka_brokers", kafka_brokers)
        if kafka_client_crt is not None:
            pulumi.set(__self__, "kafka_client_crt", kafka_client_crt)
        if kafka_client_key is not None:
            pulumi.set(__self__, "kafka_client_key", kafka_client_key)
        if max_nodes_svc_graph is not None:
            pulumi.set(__self__, "max_nodes_svc_graph", max_nodes_svc_graph)
        if mtu_head_room is not None:
            pulumi.set(__self__, "mtu_head_room", mtu_head_room)
        if multus_disable is not None:
            pulumi.set(__self__, "multus_disable", multus_disable)
        if no_priority_class is not None:
            pulumi.set(__self__, "no_priority_class", no_priority_class)
        if node_pod_if_enable is not None:
            pulumi.set(__self__, "node_pod_if_enable", node_pod_if_enable)
        if opflex_client_ssl is not None:
            pulumi.set(__self__, "opflex_client_ssl", opflex_client_ssl)
        if opflex_device_delete_timeout is not None:
            pulumi.set(__self__, "opflex_device_delete_timeout", opflex_device_delete_timeout)
        if opflex_log_level is not None:
            pulumi.set(__self__, "opflex_log_level", opflex_log_level)
        if opflex_mode is not None:
            pulumi.set(__self__, "opflex_mode", opflex_mode)
        if opflex_server_port is not None:
            pulumi.set(__self__, "opflex_server_port", opflex_server_port)
        if overlay_vrf_name is not None:
            pulumi.set(__self__, "overlay_vrf_name", overlay_vrf_name)
        if ovs_memory_limit is not None:
            pulumi.set(__self__, "ovs_memory_limit", ovs_memory_limit)
        if pbr_tracking_non_snat is not None:
            pulumi.set(__self__, "pbr_tracking_non_snat", pbr_tracking_non_snat)
        if pod_subnet_chunk_size is not None:
            pulumi.set(__self__, "pod_subnet_chunk_size", pod_subnet_chunk_size)
        if run_gbp_container is not None:
            pulumi.set(__self__, "run_gbp_container", run_gbp_container)
        if run_opflex_server_container is not None:
            pulumi.set(__self__, "run_opflex_server_container", run_opflex_server_container)
        if service_monitor_interval is not None:
            pulumi.set(__self__, "service_monitor_interval", service_monitor_interval)
        if snat_contract_scope is not None:
            pulumi.set(__self__, "snat_contract_scope", snat_contract_scope)
        if snat_namespace is not None:
            pulumi.set(__self__, "snat_namespace", snat_namespace)
        if snat_port_range_end is not None:
            pulumi.set(__self__, "snat_port_range_end", snat_port_range_end)
        if snat_port_range_start is not None:
            pulumi.set(__self__, "snat_port_range_start", snat_port_range_start)
        if snat_ports_per_node is not None:
            pulumi.set(__self__, "snat_ports_per_node", snat_ports_per_node)
        if sriov_enable is not None:
            pulumi.set(__self__, "sriov_enable", sriov_enable)
        if subnet_domain_name is not None:
            pulumi.set(__self__, "subnet_domain_name", subnet_domain_name)
        if tenant is not None:
            pulumi.set(__self__, "tenant", tenant)
        if use_aci_anywhere_crd is not None:
            pulumi.set(__self__, "use_aci_anywhere_crd", use_aci_anywhere_crd)
        if use_aci_cni_priority_class is not None:
            pulumi.set(__self__, "use_aci_cni_priority_class", use_aci_cni_priority_class)
        if use_cluster_role is not None:
            pulumi.set(__self__, "use_cluster_role", use_cluster_role)
        if use_host_netns_volume is not None:
            pulumi.set(__self__, "use_host_netns_volume", use_host_netns_volume)
        if use_opflex_server_volume is not None:
            pulumi.set(__self__, "use_opflex_server_volume", use_opflex_server_volume)
        if use_privileged_container is not None:
            pulumi.set(__self__, "use_privileged_container", use_privileged_container)
        if vmm_controller is not None:
            pulumi.set(__self__, "vmm_controller", vmm_controller)
        if vmm_domain is not None:
            pulumi.set(__self__, "vmm_domain", vmm_domain)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterRkeConfigNetworkCalicoNetworkProviderArgs:
    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 ClusterRkeConfigNetworkCanalNetworkProviderArgs:
    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 ClusterRkeConfigNetworkFlannelNetworkProviderArgs:
    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 ClusterRkeConfigNetworkTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterRkeConfigNetworkWeaveNetworkProviderArgs:
    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 ClusterRkeConfigNodeArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 roles: pulumi.Input[Sequence[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 (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[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "roles")

    @roles.setter
    def roles(self, value: pulumi.Input[Sequence[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 (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 ClusterRkeConfigPrivateRegistryArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 ecr_credential_plugin: Optional[pulumi.Input['ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs']] = None,
                 is_default: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs'] ecr_credential_plugin: ECR credential plugin config
        """
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        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="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional[pulumi.Input['ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs']]:
        """
        ECR credential plugin config
        """
        return pulumi.get(self, "ecr_credential_plugin")

    @ecr_credential_plugin.setter
    def ecr_credential_plugin(self, value: Optional[pulumi.Input['ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs']]):
        pulumi.set(self, "ecr_credential_plugin", 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 ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs:
    def __init__(__self__, *,
                 aws_access_key_id: Optional[pulumi.Input[str]] = None,
                 aws_secret_access_key: Optional[pulumi.Input[str]] = None,
                 aws_session_token: Optional[pulumi.Input[str]] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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

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

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

    @aws_session_token.setter
    def aws_session_token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aws_session_token", 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):
        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']]:
        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']]:
        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']]:
        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']]:
        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']]:
        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']]:
        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[Sequence[pulumi.Input[str]]]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 gid: Optional[pulumi.Input[int]] = 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[int]] = None):
        """
        :param pulumi.Input[str] ca_cert: (Computed/Sensitive) K8s cluster ca cert (string)
        """
        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']]:
        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]]:
        """
        (Computed/Sensitive) K8s cluster ca cert (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]]:
        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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "external_urls")

    @external_urls.setter
    def external_urls(self, value: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

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

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

    @gid.setter
    def gid(self, value: Optional[pulumi.Input[int]]):
        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[int]]:
        return pulumi.get(self, "uid")

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


@pulumi.input_type
class ClusterRkeConfigServicesEtcdBackupConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 interval_hours: Optional[pulumi.Input[int]] = None,
                 retention: Optional[pulumi.Input[int]] = None,
                 s3_backup_config: Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']] = None,
                 safe_timestamp: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[int]] = None):
        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)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[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[int]]:
        return pulumi.get(self, "interval_hours")

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

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

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

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional[pulumi.Input['ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']]:
        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]]:
        return pulumi.get(self, "safe_timestamp")

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

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

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timeout", 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):
        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 ClusterRkeConfigServicesKubeApiArgs:
    def __init__(__self__, *,
                 admission_configuration: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs']] = 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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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['ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs'] admission_configuration: Cluster admission configuration
        """
        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['ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs']]:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @admission_configuration.setter
    def admission_configuration(self, value: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs']]):
        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['ClusterRkeConfigServicesKubeApiAuditLogArgs']]:
        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']]:
        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]]]:
        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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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['ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs']]:
        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]]:
        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 ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 kind: Optional[pulumi.Input[str]] = None,
                 plugins: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]]] = None):
        """
        :param pulumi.Input[str] api_version: Admission configuration ApiVersion
        :param pulumi.Input[str] kind: Admission configuration Kind
        :param pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]] plugins: Admission configuration plugins
        """
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if plugins is not None:
            pulumi.set(__self__, "plugins", plugins)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[pulumi.Input[str]]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

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

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

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

    @property
    @pulumi.getter
    def plugins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]]]:
        """
        Admission configuration plugins
        """
        return pulumi.get(self, "plugins")

    @plugins.setter
    def plugins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]]]):
        pulumi.set(self, "plugins", value)


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] configuration: Plugin configuration
        :param pulumi.Input[str] name: The name of the Cluster (string)
        :param pulumi.Input[str] path: Plugin path
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)

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

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

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

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

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

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


@pulumi.input_type
class ClusterRkeConfigServicesKubeApiAuditLogArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input['ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs']] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        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']]:
        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]]:
        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[int]] = None,
                 max_backup: Optional[pulumi.Input[int]] = None,
                 max_size: Optional[pulumi.Input[int]] = 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[int]]:
        return pulumi.get(self, "max_age")

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

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

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

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

    @max_size.setter
    def max_size(self, value: Optional[pulumi.Input[int]]):
        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 ClusterRkeConfigServicesKubeApiEventRateLimitArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        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]]:
        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):
        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]]:
        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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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 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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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 ClusterRkeConfigServicesKubeproxyArgs:
    def __init__(__self__, *,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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 ClusterRkeConfigServicesSchedulerArgs:
    def __init__(__self__, *,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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 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):
        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['ClusterRkeConfigUpgradeStrategyDrainInputArgs']]:
        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]]:
        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 ClusterRkeConfigUpgradeStrategyDrainInputArgs:
    def __init__(__self__, *,
                 delete_local_data: Optional[pulumi.Input[bool]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 grace_period: Optional[pulumi.Input[int]] = None,
                 ignore_daemon_sets: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[int]] = 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[int]]:
        return pulumi.get(self, "grace_period")

    @grace_period.setter
    def grace_period(self, value: Optional[pulumi.Input[int]]):
        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[int]]:
        return pulumi.get(self, "timeout")

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


@pulumi.input_type
class ClusterSyncNodeArgs:
    def __init__(__self__, *,
                 annotations: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 capacity: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 cluster_id: Optional[pulumi.Input[str]] = None,
                 external_ip_address: Optional[pulumi.Input[str]] = None,
                 hostname: Optional[pulumi.Input[str]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 ip_address: Optional[pulumi.Input[str]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 node_pool_id: Optional[pulumi.Input[str]] = None,
                 node_template_id: Optional[pulumi.Input[str]] = None,
                 provider_id: Optional[pulumi.Input[str]] = None,
                 requested_hostname: Optional[pulumi.Input[str]] = None,
                 roles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ssh_user: Optional[pulumi.Input[str]] = None,
                 system_info: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] annotations: Annotations of the resource
        :param pulumi.Input[str] cluster_id: The cluster ID that is syncing (string)
        :param pulumi.Input[str] id: (Computed) The ID of the resource. Same as `cluster_id` (string)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels of the resource
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if external_ip_address is not None:
            pulumi.set(__self__, "external_ip_address", external_ip_address)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_pool_id is not None:
            pulumi.set(__self__, "node_pool_id", node_pool_id)
        if node_template_id is not None:
            pulumi.set(__self__, "node_template_id", node_template_id)
        if provider_id is not None:
            pulumi.set(__self__, "provider_id", provider_id)
        if requested_hostname is not None:
            pulumi.set(__self__, "requested_hostname", requested_hostname)
        if roles is not None:
            pulumi.set(__self__, "roles", roles)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if system_info is not None:
            pulumi.set(__self__, "system_info", system_info)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Annotations of the resource
        """
        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
    def capacity(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "capacity")

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

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[pulumi.Input[str]]:
        """
        The cluster ID that is syncing (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="externalIpAddress")
    def external_ip_address(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "external_ip_address")

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

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

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        (Computed) The ID of the resource. Same as `cluster_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(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
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels of the resource
        """
        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 name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        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="systemInfo")
    def system_info(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "system_info")

    @system_info.setter
    def system_info(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "system_info", 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: member, owner, read-only
        :param pulumi.Input[str] group_principal_id: Member group principal id
        :param pulumi.Input[str] user_principal_id: Member user principal id
        """
        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: member, owner, read-only
        """
        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
        """
        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
        """
        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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigArgs'] cluster_config: Cluster configuration
        :param pulumi.Input[str] name: The cluster template name (string)
        :param pulumi.Input[Mapping[str, Any]] annotations: Annotations for the cluster template (map)
        :param pulumi.Input[str] cluster_template_id: Cluster template ID
        :param pulumi.Input[bool] default: Default cluster template revision
        :param pulumi.Input[bool] enabled: Enable cluster template revision
        :param pulumi.Input[str] id: (Computed) The ID of the resource (string)
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the cluster template (map)
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]] questions: Cluster template questions
        """
        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
        """
        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 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 (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
        """
        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 cluster template revision
        """
        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
        """
        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]]:
        """
        (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
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the cluster template (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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionQuestionArgs']]]]:
        """
        Cluster template questions
        """
        return pulumi.get(self, "questions")

    @questions.setter
    def questions(self, value: Optional[pulumi.Input[Sequence[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_admission_configuration_template_name: 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,
                 windows_prefered_cluster: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs'] rke_config: Rancher Kubernetes Engine Config
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs'] cluster_auth_endpoint: Local cluster auth endpoint
        :param pulumi.Input[str] default_cluster_role_for_project_members: Default cluster role for project members
        :param pulumi.Input[str] default_pod_security_admission_configuration_template_name: Default pod security admission configuration template name
        :param pulumi.Input[str] default_pod_security_policy_template_id: Default pod security policy template ID
        :param pulumi.Input[str] desired_agent_image: Desired agent image
        :param pulumi.Input[str] desired_auth_image: Desired auth image
        :param pulumi.Input[str] docker_root_dir: Docker Root Dir
        :param pulumi.Input[bool] enable_cluster_alerting: Enable built-in cluster alerting
        :param pulumi.Input[bool] enable_cluster_monitoring: Enable built-in cluster monitoring
        :param pulumi.Input[bool] enable_network_policy: Enable project network isolation
        :param pulumi.Input[bool] windows_prefered_cluster: Windows prefered cluster
        """
        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_admission_configuration_template_name is not None:
            pulumi.set(__self__, "default_pod_security_admission_configuration_template_name", default_pod_security_admission_configuration_template_name)
        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 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
        """
        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
        """
        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
        """
        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="defaultPodSecurityAdmissionConfigurationTemplateName")
    def default_pod_security_admission_configuration_template_name(self) -> Optional[pulumi.Input[str]]:
        """
        Default pod security admission configuration template name
        """
        return pulumi.get(self, "default_pod_security_admission_configuration_template_name")

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

    @property
    @pulumi.getter(name="defaultPodSecurityPolicyTemplateId")
    def default_pod_security_policy_template_id(self) -> Optional[pulumi.Input[str]]:
        """
        Default pod security policy template ID
        """
        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
        """
        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
        """
        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]]:
        """
        Docker Root Dir
        """
        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
        """
        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
        """
        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
        """
        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="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[pulumi.Input[bool]]:
        """
        Windows prefered cluster
        """
        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):
        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]]:
        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[int]] = None,
                 addons: Optional[pulumi.Input[str]] = None,
                 addons_includes: Optional[pulumi.Input[Sequence[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,
                 enable_cri_dockerd: Optional[pulumi.Input[bool]] = 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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs']]]] = None,
                 prefix_path: Optional[pulumi.Input[str]] = None,
                 private_registries: Optional[pulumi.Input[Sequence[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,
                 win_prefix_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] addon_job_timeout: Optional duration in seconds of addon job.
        :param pulumi.Input[str] addons: Optional addons descripton to deploy on rke cluster.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs'] authentication: Kubernetes cluster authentication
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs'] authorization: Kubernetes cluster authorization
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs'] bastion_host: RKE bastion host
        :param pulumi.Input[bool] enable_cri_dockerd: Enable/disable using cri-dockerd
        :param pulumi.Input[bool] ignore_docker_version: Optional ignore docker version on nodes
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs'] ingress: Kubernetes ingress configuration
        :param pulumi.Input[str] kubernetes_version: Optional kubernetes version to deploy
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs'] monitoring: Kubernetes cluster monitoring
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs'] network: Kubernetes cluster networking
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs']]] nodes: Optional RKE cluster nodes
        :param pulumi.Input[str] prefix_path: Optional prefix to customize kubernetes path
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs']]] private_registries: Optional private registries for docker images
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs'] services: Kubernetes cluster services
        :param pulumi.Input[bool] ssh_agent_auth: Optional use ssh agent auth
        :param pulumi.Input[str] ssh_cert_path: Optional cluster level SSH certificate path
        :param pulumi.Input[str] ssh_key_path: Optional cluster level SSH private key path
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs'] upgrade_strategy: RKE upgrade strategy
        :param pulumi.Input[str] win_prefix_path: Optional prefix to customize kubernetes path for windows
        """
        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 enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        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)
        if win_prefix_path is not None:
            pulumi.set(__self__, "win_prefix_path", win_prefix_path)

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

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

    @property
    @pulumi.getter
    def addons(self) -> Optional[pulumi.Input[str]]:
        """
        Optional 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[Sequence[pulumi.Input[str]]]]:
        """
        Optional addons yaml manisfest to deploy on rke cluster.
        """
        return pulumi.get(self, "addons_includes")

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

    @property
    @pulumi.getter
    def authentication(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs']]:
        """
        Kubernetes cluster authentication
        """
        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']]:
        """
        Kubernetes cluster authorization
        """
        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']]:
        """
        RKE bastion host
        """
        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="enableCriDockerd")
    def enable_cri_dockerd(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

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

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[pulumi.Input[bool]]:
        """
        Optional ignore docker version on nodes
        """
        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']]:
        """
        Kubernetes ingress configuration
        """
        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]]:
        """
        Optional kubernetes version to deploy
        """
        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']]:
        """
        Kubernetes cluster monitoring
        """
        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']]:
        """
        Kubernetes cluster networking
        """
        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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs']]]]:
        """
        Optional RKE cluster nodes
        """
        return pulumi.get(self, "nodes")

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

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> Optional[pulumi.Input[str]]:
        """
        Optional prefix to customize kubernetes path
        """
        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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs']]]]:
        """
        Optional private registries for docker images
        """
        return pulumi.get(self, "private_registries")

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

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs']]:
        """
        Kubernetes cluster services
        """
        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]]:
        """
        Optional use ssh agent auth
        """
        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]]:
        """
        Optional cluster level SSH certificate path
        """
        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]]:
        """
        Optional cluster level SSH private key path
        """
        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']]:
        """
        RKE upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

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

    @property
    @pulumi.getter(name="winPrefixPath")
    def win_prefix_path(self) -> Optional[pulumi.Input[str]]:
        """
        Optional prefix to customize kubernetes path for windows
        """
        return pulumi.get(self, "win_prefix_path")

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs:
    def __init__(__self__, *,
                 sans: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "sans")

    @sans.setter
    def sans(self, value: Optional[pulumi.Input[Sequence[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 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 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[Sequence[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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs']]]]:
        return pulumi.get(self, "service_overrides")

    @service_overrides.setter
    def service_overrides(self, value: Optional[pulumi.Input[Sequence[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[int]] = None,
                 cloud_provider_backoff_exponent: Optional[pulumi.Input[int]] = None,
                 cloud_provider_backoff_jitter: Optional[pulumi.Input[int]] = None,
                 cloud_provider_backoff_retries: Optional[pulumi.Input[int]] = None,
                 cloud_provider_rate_limit: Optional[pulumi.Input[bool]] = None,
                 cloud_provider_rate_limit_bucket: Optional[pulumi.Input[int]] = None,
                 cloud_provider_rate_limit_qps: Optional[pulumi.Input[int]] = None,
                 load_balancer_sku: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 maximum_load_balancer_rule_count: Optional[pulumi.Input[int]] = 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] load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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[int]]:
        return pulumi.get(self, "cloud_provider_backoff_duration")

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

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

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

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

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

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

    @cloud_provider_backoff_retries.setter
    def cloud_provider_backoff_retries(self, value: Optional[pulumi.Input[int]]):
        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[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[int]]):
        pulumi.set(self, "cloud_provider_rate_limit_bucket", value)

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> Optional[pulumi.Input[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[int]]):
        pulumi.set(self, "cloud_provider_rate_limit_qps", value)

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[pulumi.Input[str]]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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[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[int]]):
        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[int]] = 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[int]]:
        return pulumi.get(self, "monitor_max_retries")

    @monitor_max_retries.setter
    def monitor_max_retries(self, value: Optional[pulumi.Input[int]]):
        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[int]] = 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[int]]:
        return pulumi.get(self, "request_timeout")

    @request_timeout.setter
    def request_timeout(self, value: Optional[pulumi.Input[int]]):
        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[Sequence[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[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs']]]:
        return pulumi.get(self, "virtual_centers")

    @virtual_centers.setter
    def virtual_centers(self, value: pulumi.Input[Sequence[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,
                 graceful_shutdown_timeout: 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[int]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        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="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "graceful_shutdown_timeout")

    @graceful_shutdown_timeout.setter
    def graceful_shutdown_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "graceful_shutdown_timeout", 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[int]]:
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[int]]):
        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[int]] = None):
        """
        :param pulumi.Input[str] name: The cluster template 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 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[int]]:
        return pulumi.get(self, "soap_roundtrip_count")

    @soap_roundtrip_count.setter
    def soap_roundtrip_count(self, value: Optional[pulumi.Input[int]]):
        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__, *,
                 linear_autoscaler_params: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs']] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 nodelocal: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs']] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 reverse_cidrs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs']]]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs']] = None,
                 upstream_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs'] linear_autoscaler_params: Linear Autoscaler Params
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs'] nodelocal: Nodelocal dns
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs']]] tolerations: DNS service tolerations
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs'] update_strategy: Update deployment strategy
        """
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs']]:
        """
        Linear Autoscaler Params
        """
        return pulumi.get(self, "linear_autoscaler_params")

    @linear_autoscaler_params.setter
    def linear_autoscaler_params(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs']]):
        pulumi.set(self, "linear_autoscaler_params", 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 nodelocal(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs']]:
        """
        Nodelocal dns
        """
        return pulumi.get(self, "nodelocal")

    @nodelocal.setter
    def nodelocal(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs']]):
        pulumi.set(self, "nodelocal", 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(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "reverse_cidrs")

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs']]]]:
        """
        DNS service tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs']]:
        """
        Update deployment strategy
        """
        return pulumi.get(self, "update_strategy")

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

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

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs:
    def __init__(__self__, *,
                 cores_per_replica: Optional[pulumi.Input[float]] = None,
                 max: Optional[pulumi.Input[int]] = None,
                 min: Optional[pulumi.Input[int]] = None,
                 nodes_per_replica: Optional[pulumi.Input[float]] = None,
                 prevent_single_point_failure: Optional[pulumi.Input[bool]] = None):
        if cores_per_replica is not None:
            pulumi.set(__self__, "cores_per_replica", cores_per_replica)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)
        if nodes_per_replica is not None:
            pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
        if prevent_single_point_failure is not None:
            pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)

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

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

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

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

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

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

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

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

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

    @prevent_single_point_failure.setter
    def prevent_single_point_failure(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prevent_single_point_failure", 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):
        """
        :param pulumi.Input[Mapping[str, Any]] node_selector: Node selector key pair
        """
        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]]]:
        """
        Node selector key pair
        """
        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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs'] rolling_update: Rolling update for update strategy
        :param pulumi.Input[str] strategy: Strategy
        """
        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['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs']]:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

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

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

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_surge: Optional[pulumi.Input[int]] = None,
                 max_unavailable: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_surge: Rolling update max surge
        :param pulumi.Input[int] max_unavailable: Rolling update max unavailable
        """
        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[int]]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

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

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs:
    def __init__(__self__, *,
                 default_backend: Optional[pulumi.Input[bool]] = None,
                 dns_policy: Optional[pulumi.Input[str]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 http_port: Optional[pulumi.Input[int]] = None,
                 https_port: Optional[pulumi.Input[int]] = None,
                 network_mode: Optional[pulumi.Input[str]] = None,
                 node_selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 provider: Optional[pulumi.Input[str]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs']]]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs']]] tolerations: Ingress add-on tolerations
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs'] update_strategy: Update daemon set strategy
        """
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        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 http_port is not None:
            pulumi.set(__self__, "http_port", http_port)
        if https_port is not None:
            pulumi.set(__self__, "https_port", https_port)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

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

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

    @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="httpPort")
    def http_port(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "http_port")

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

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

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

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

    @network_mode.setter
    def network_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_mode", 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)

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs']]]]:
        """
        Ingress add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs']]:
        """
        Update daemon set strategy
        """
        return pulumi.get(self, "update_strategy")

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs'] rolling_update: Rolling update for update strategy
        :param pulumi.Input[str] strategy: Strategy
        """
        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['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs']]:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

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

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

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs:
    def __init__(__self__, *,
                 max_unavailable: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_unavailable: Rolling update max unavailable
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable", 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[int]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs']]]] = None,
                 update_strategy: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs']]] tolerations: Monitoring add-on tolerations
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs'] update_strategy: Update deployment strategy
        """
        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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        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[int]]:
        return pulumi.get(self, "replicas")

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs']]]]:
        """
        Monitoring add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs']]]]):
        pulumi.set(self, "tolerations", value)

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs']]:
        """
        Update deployment strategy
        """
        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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs:
    def __init__(__self__, *,
                 rolling_update: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs']] = None,
                 strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs'] rolling_update: Rolling update for update strategy
        :param pulumi.Input[str] strategy: Strategy
        """
        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']]:
        """
        Rolling update for update strategy
        """
        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]]:
        """
        Strategy
        """
        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[int]] = None,
                 max_unavailable: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] max_surge: Rolling update max surge
        :param pulumi.Input[int] max_unavailable: Rolling update max unavailable
        """
        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[int]]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

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

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs:
    def __init__(__self__, *,
                 aci_network_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderArgs']] = None,
                 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[int]] = None,
                 options: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 plugin: Optional[pulumi.Input[str]] = None,
                 tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs']]]] = None,
                 weave_network_provider: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs']]] tolerations: Network add-on tolerations
        """
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="aciNetworkProvider")
    def aci_network_provider(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderArgs']]:
        return pulumi.get(self, "aci_network_provider")

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

    @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[int]]:
        return pulumi.get(self, "mtu")

    @mtu.setter
    def mtu(self, value: Optional[pulumi.Input[int]]):
        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
    def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs']]]]:
        """
        Network add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @tolerations.setter
    def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs']]]]):
        pulumi.set(self, "tolerations", 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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderArgs:
    def __init__(__self__, *,
                 aep: pulumi.Input[str],
                 apic_hosts: pulumi.Input[Sequence[pulumi.Input[str]]],
                 apic_user_crt: pulumi.Input[str],
                 apic_user_key: pulumi.Input[str],
                 apic_user_name: pulumi.Input[str],
                 encap_type: pulumi.Input[str],
                 extern_dynamic: pulumi.Input[str],
                 extern_static: pulumi.Input[str],
                 kube_api_vlan: pulumi.Input[str],
                 l3out: pulumi.Input[str],
                 l3out_external_networks: pulumi.Input[Sequence[pulumi.Input[str]]],
                 mcast_range_end: pulumi.Input[str],
                 mcast_range_start: pulumi.Input[str],
                 node_subnet: pulumi.Input[str],
                 node_svc_subnet: pulumi.Input[str],
                 service_vlan: pulumi.Input[str],
                 system_id: pulumi.Input[str],
                 token: pulumi.Input[str],
                 vrf_name: pulumi.Input[str],
                 vrf_tenant: pulumi.Input[str],
                 apic_refresh_ticker_adjust: Optional[pulumi.Input[str]] = None,
                 apic_refresh_time: Optional[pulumi.Input[str]] = None,
                 apic_subscription_delay: Optional[pulumi.Input[str]] = None,
                 capic: Optional[pulumi.Input[str]] = None,
                 controller_log_level: Optional[pulumi.Input[str]] = None,
                 disable_periodic_snat_global_info_sync: Optional[pulumi.Input[str]] = None,
                 disable_wait_for_network: Optional[pulumi.Input[str]] = None,
                 drop_log_enable: Optional[pulumi.Input[str]] = None,
                 duration_wait_for_network: Optional[pulumi.Input[str]] = None,
                 enable_endpoint_slice: Optional[pulumi.Input[str]] = None,
                 ep_registry: Optional[pulumi.Input[str]] = None,
                 gbp_pod_subnet: Optional[pulumi.Input[str]] = None,
                 host_agent_log_level: Optional[pulumi.Input[str]] = None,
                 image_pull_policy: Optional[pulumi.Input[str]] = None,
                 image_pull_secret: Optional[pulumi.Input[str]] = None,
                 infra_vlan: Optional[pulumi.Input[str]] = None,
                 install_istio: Optional[pulumi.Input[str]] = None,
                 istio_profile: Optional[pulumi.Input[str]] = None,
                 kafka_brokers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kafka_client_crt: Optional[pulumi.Input[str]] = None,
                 kafka_client_key: Optional[pulumi.Input[str]] = None,
                 max_nodes_svc_graph: Optional[pulumi.Input[str]] = None,
                 mtu_head_room: Optional[pulumi.Input[str]] = None,
                 multus_disable: Optional[pulumi.Input[str]] = None,
                 no_priority_class: Optional[pulumi.Input[str]] = None,
                 node_pod_if_enable: Optional[pulumi.Input[str]] = None,
                 opflex_client_ssl: Optional[pulumi.Input[str]] = None,
                 opflex_device_delete_timeout: Optional[pulumi.Input[str]] = None,
                 opflex_log_level: Optional[pulumi.Input[str]] = None,
                 opflex_mode: Optional[pulumi.Input[str]] = None,
                 opflex_server_port: Optional[pulumi.Input[str]] = None,
                 overlay_vrf_name: Optional[pulumi.Input[str]] = None,
                 ovs_memory_limit: Optional[pulumi.Input[str]] = None,
                 pbr_tracking_non_snat: Optional[pulumi.Input[str]] = None,
                 pod_subnet_chunk_size: Optional[pulumi.Input[str]] = None,
                 run_gbp_container: Optional[pulumi.Input[str]] = None,
                 run_opflex_server_container: Optional[pulumi.Input[str]] = None,
                 service_monitor_interval: Optional[pulumi.Input[str]] = None,
                 snat_contract_scope: Optional[pulumi.Input[str]] = None,
                 snat_namespace: Optional[pulumi.Input[str]] = None,
                 snat_port_range_end: Optional[pulumi.Input[str]] = None,
                 snat_port_range_start: Optional[pulumi.Input[str]] = None,
                 snat_ports_per_node: Optional[pulumi.Input[str]] = None,
                 sriov_enable: Optional[pulumi.Input[str]] = None,
                 subnet_domain_name: Optional[pulumi.Input[str]] = None,
                 tenant: Optional[pulumi.Input[str]] = None,
                 use_aci_anywhere_crd: Optional[pulumi.Input[str]] = None,
                 use_aci_cni_priority_class: Optional[pulumi.Input[str]] = None,
                 use_cluster_role: Optional[pulumi.Input[str]] = None,
                 use_host_netns_volume: Optional[pulumi.Input[str]] = None,
                 use_opflex_server_volume: Optional[pulumi.Input[str]] = None,
                 use_privileged_container: Optional[pulumi.Input[str]] = None,
                 vmm_controller: Optional[pulumi.Input[str]] = None,
                 vmm_domain: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "aep", aep)
        pulumi.set(__self__, "apic_hosts", apic_hosts)
        pulumi.set(__self__, "apic_user_crt", apic_user_crt)
        pulumi.set(__self__, "apic_user_key", apic_user_key)
        pulumi.set(__self__, "apic_user_name", apic_user_name)
        pulumi.set(__self__, "encap_type", encap_type)
        pulumi.set(__self__, "extern_dynamic", extern_dynamic)
        pulumi.set(__self__, "extern_static", extern_static)
        pulumi.set(__self__, "kube_api_vlan", kube_api_vlan)
        pulumi.set(__self__, "l3out", l3out)
        pulumi.set(__self__, "l3out_external_networks", l3out_external_networks)
        pulumi.set(__self__, "mcast_range_end", mcast_range_end)
        pulumi.set(__self__, "mcast_range_start", mcast_range_start)
        pulumi.set(__self__, "node_subnet", node_subnet)
        pulumi.set(__self__, "node_svc_subnet", node_svc_subnet)
        pulumi.set(__self__, "service_vlan", service_vlan)
        pulumi.set(__self__, "system_id", system_id)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "vrf_name", vrf_name)
        pulumi.set(__self__, "vrf_tenant", vrf_tenant)
        if apic_refresh_ticker_adjust is not None:
            pulumi.set(__self__, "apic_refresh_ticker_adjust", apic_refresh_ticker_adjust)
        if apic_refresh_time is not None:
            pulumi.set(__self__, "apic_refresh_time", apic_refresh_time)
        if apic_subscription_delay is not None:
            pulumi.set(__self__, "apic_subscription_delay", apic_subscription_delay)
        if capic is not None:
            pulumi.set(__self__, "capic", capic)
        if controller_log_level is not None:
            pulumi.set(__self__, "controller_log_level", controller_log_level)
        if disable_periodic_snat_global_info_sync is not None:
            pulumi.set(__self__, "disable_periodic_snat_global_info_sync", disable_periodic_snat_global_info_sync)
        if disable_wait_for_network is not None:
            pulumi.set(__self__, "disable_wait_for_network", disable_wait_for_network)
        if drop_log_enable is not None:
            pulumi.set(__self__, "drop_log_enable", drop_log_enable)
        if duration_wait_for_network is not None:
            pulumi.set(__self__, "duration_wait_for_network", duration_wait_for_network)
        if enable_endpoint_slice is not None:
            pulumi.set(__self__, "enable_endpoint_slice", enable_endpoint_slice)
        if ep_registry is not None:
            pulumi.set(__self__, "ep_registry", ep_registry)
        if gbp_pod_subnet is not None:
            pulumi.set(__self__, "gbp_pod_subnet", gbp_pod_subnet)
        if host_agent_log_level is not None:
            pulumi.set(__self__, "host_agent_log_level", host_agent_log_level)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if infra_vlan is not None:
            pulumi.set(__self__, "infra_vlan", infra_vlan)
        if install_istio is not None:
            pulumi.set(__self__, "install_istio", install_istio)
        if istio_profile is not None:
            pulumi.set(__self__, "istio_profile", istio_profile)
        if kafka_brokers is not None:
            pulumi.set(__self__, "kafka_brokers", kafka_brokers)
        if kafka_client_crt is not None:
            pulumi.set(__self__, "kafka_client_crt", kafka_client_crt)
        if kafka_client_key is not None:
            pulumi.set(__self__, "kafka_client_key", kafka_client_key)
        if max_nodes_svc_graph is not None:
            pulumi.set(__self__, "max_nodes_svc_graph", max_nodes_svc_graph)
        if mtu_head_room is not None:
            pulumi.set(__self__, "mtu_head_room", mtu_head_room)
        if multus_disable is not None:
            pulumi.set(__self__, "multus_disable", multus_disable)
        if no_priority_class is not None:
            pulumi.set(__self__, "no_priority_class", no_priority_class)
        if node_pod_if_enable is not None:
            pulumi.set(__self__, "node_pod_if_enable", node_pod_if_enable)
        if opflex_client_ssl is not None:
            pulumi.set(__self__, "opflex_client_ssl", opflex_client_ssl)
        if opflex_device_delete_timeout is not None:
            pulumi.set(__self__, "opflex_device_delete_timeout", opflex_device_delete_timeout)
        if opflex_log_level is not None:
            pulumi.set(__self__, "opflex_log_level", opflex_log_level)
        if opflex_mode is not None:
            pulumi.set(__self__, "opflex_mode", opflex_mode)
        if opflex_server_port is not None:
            pulumi.set(__self__, "opflex_server_port", opflex_server_port)
        if overlay_vrf_name is not None:
            pulumi.set(__self__, "overlay_vrf_name", overlay_vrf_name)
        if ovs_memory_limit is not None:
            pulumi.set(__self__, "ovs_memory_limit", ovs_memory_limit)
        if pbr_tracking_non_snat is not None:
            pulumi.set(__self__, "pbr_tracking_non_snat", pbr_tracking_non_snat)
        if pod_subnet_chunk_size is not None:
            pulumi.set(__self__, "pod_subnet_chunk_size", pod_subnet_chunk_size)
        if run_gbp_container is not None:
            pulumi.set(__self__, "run_gbp_container", run_gbp_container)
        if run_opflex_server_container is not None:
            pulumi.set(__self__, "run_opflex_server_container", run_opflex_server_container)
        if service_monitor_interval is not None:
            pulumi.set(__self__, "service_monitor_interval", service_monitor_interval)
        if snat_contract_scope is not None:
            pulumi.set(__self__, "snat_contract_scope", snat_contract_scope)
        if snat_namespace is not None:
            pulumi.set(__self__, "snat_namespace", snat_namespace)
        if snat_port_range_end is not None:
            pulumi.set(__self__, "snat_port_range_end", snat_port_range_end)
        if snat_port_range_start is not None:
            pulumi.set(__self__, "snat_port_range_start", snat_port_range_start)
        if snat_ports_per_node is not None:
            pulumi.set(__self__, "snat_ports_per_node", snat_ports_per_node)
        if sriov_enable is not None:
            pulumi.set(__self__, "sriov_enable", sriov_enable)
        if subnet_domain_name is not None:
            pulumi.set(__self__, "subnet_domain_name", subnet_domain_name)
        if tenant is not None:
            pulumi.set(__self__, "tenant", tenant)
        if use_aci_anywhere_crd is not None:
            pulumi.set(__self__, "use_aci_anywhere_crd", use_aci_anywhere_crd)
        if use_aci_cni_priority_class is not None:
            pulumi.set(__self__, "use_aci_cni_priority_class", use_aci_cni_priority_class)
        if use_cluster_role is not None:
            pulumi.set(__self__, "use_cluster_role", use_cluster_role)
        if use_host_netns_volume is not None:
            pulumi.set(__self__, "use_host_netns_volume", use_host_netns_volume)
        if use_opflex_server_volume is not None:
            pulumi.set(__self__, "use_opflex_server_volume", use_opflex_server_volume)
        if use_privileged_container is not None:
            pulumi.set(__self__, "use_privileged_container", use_privileged_container)
        if vmm_controller is not None:
            pulumi.set(__self__, "vmm_controller", vmm_controller)
        if vmm_domain is not None:
            pulumi.set(__self__, "vmm_domain", vmm_domain)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @vmm_domain.setter
    def vmm_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vmm_domain", 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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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

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

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", 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[Sequence[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 (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[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "roles")

    @roles.setter
    def roles(self, value: pulumi.Input[Sequence[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 (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],
                 ecr_credential_plugin: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs']] = None,
                 is_default: Optional[pulumi.Input[bool]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs'] ecr_credential_plugin: ECR credential plugin config
        """
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        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="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs']]:
        """
        ECR credential plugin config
        """
        return pulumi.get(self, "ecr_credential_plugin")

    @ecr_credential_plugin.setter
    def ecr_credential_plugin(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs']]):
        pulumi.set(self, "ecr_credential_plugin", 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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs:
    def __init__(__self__, *,
                 aws_access_key_id: Optional[pulumi.Input[str]] = None,
                 aws_secret_access_key: Optional[pulumi.Input[str]] = None,
                 aws_session_token: Optional[pulumi.Input[str]] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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

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

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

    @aws_session_token.setter
    def aws_session_token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aws_session_token", 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[Sequence[pulumi.Input[str]]]] = None,
                 extra_args: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 extra_binds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 gid: Optional[pulumi.Input[int]] = 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[int]] = 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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "external_urls")

    @external_urls.setter
    def external_urls(self, value: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

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

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

    @gid.setter
    def gid(self, value: Optional[pulumi.Input[int]]):
        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[int]]:
        return pulumi.get(self, "uid")

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 interval_hours: Optional[pulumi.Input[int]] = None,
                 retention: Optional[pulumi.Input[int]] = None,
                 s3_backup_config: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs']] = None,
                 safe_timestamp: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[int]] = None):
        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)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[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[int]]:
        return pulumi.get(self, "interval_hours")

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

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

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[int]]):
        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)

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

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timeout", 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['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs']] = 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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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):
        """
        :param pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs'] admission_configuration: Cluster admission configuration
        """
        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['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs']]:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @admission_configuration.setter
    def admission_configuration(self, value: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs']]):
        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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 kind: Optional[pulumi.Input[str]] = None,
                 plugins: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]]] = None):
        """
        :param pulumi.Input[str] api_version: Admission configuration ApiVersion
        :param pulumi.Input[str] kind: Admission configuration Kind
        :param pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]] plugins: Admission configuration plugins
        """
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if plugins is not None:
            pulumi.set(__self__, "plugins", plugins)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[pulumi.Input[str]]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

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

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

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

    @property
    @pulumi.getter
    def plugins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]]]:
        """
        Admission configuration plugins
        """
        return pulumi.get(self, "plugins")

    @plugins.setter
    def plugins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs']]]]):
        pulumi.set(self, "plugins", value)


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] configuration: Plugin configuration
        :param pulumi.Input[str] name: The cluster template name (string)
        :param pulumi.Input[str] path: Plugin path
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)

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

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The cluster template 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
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")

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


@pulumi.input_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogArgs:
    def __init__(__self__, *,
                 configuration: Optional[pulumi.Input['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationArgs']] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        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]]:
        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[int]] = None,
                 max_backup: Optional[pulumi.Input[int]] = None,
                 max_size: Optional[pulumi.Input[int]] = 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[int]]:
        return pulumi.get(self, "max_age")

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

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

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

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

    @max_size.setter
    def max_size(self, value: Optional[pulumi.Input[int]]):
        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):
        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]]:
        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):
        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]]:
        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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]] = None,
                 extra_envs: Optional[pulumi.Input[Sequence[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[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "extra_binds")

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

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

    @extra_envs.setter
    def extra_envs(self, value: Optional[pulumi.Input[Sequence[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[int]] = None,
                 ignore_daemon_sets: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[int]] = 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[int]]:
        return pulumi.get(self, "grace_period")

    @grace_period.setter
    def grace_period(self, value: Optional[pulumi.Input[int]]):
        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[int]]:
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timeout", 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
        :param pulumi.Input[str] variable: Variable name
        :param pulumi.Input[bool] required: Required variable
        :param pulumi.Input[str] type: Variable type
        """
        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
        """
        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
        """
        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
        """
        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
        """
        return pulumi.get(self, "type")

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


@pulumi.input_type
class ClusterV2AgentEnvVarArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the cluster.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

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

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

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


@pulumi.input_type
class ClusterV2ClusterAgentDeploymentCustomizationArgs:
    def __init__(__self__, *,
                 append_tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs']]]] = None,
                 override_affinity: Optional[pulumi.Input[str]] = None,
                 override_resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs']]] append_tolerations: User defined tolerations to append to agent
        :param pulumi.Input[str] override_affinity: User defined affinity to override default agent affinity
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]] override_resource_requirements: User defined resource requirements to set on the agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)

    @property
    @pulumi.getter(name="appendTolerations")
    def append_tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs']]]]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @append_tolerations.setter
    def append_tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs']]]]):
        pulumi.set(self, "append_tolerations", value)

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        User defined affinity to override default agent affinity
        """
        return pulumi.get(self, "override_affinity")

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

    @property
    @pulumi.getter(name="overrideResourceRequirements")
    def override_resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]:
        """
        User defined resource requirements to set on the agent
        """
        return pulumi.get(self, "override_resource_requirements")

    @override_resource_requirements.setter
    def override_resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]):
        pulumi.set(self, "override_resource_requirements", value)


@pulumi.input_type
class ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs:
    def __init__(__self__, *,
                 cpu_limit: Optional[pulumi.Input[str]] = None,
                 cpu_request: Optional[pulumi.Input[str]] = None,
                 memory_limit: Optional[pulumi.Input[str]] = None,
                 memory_request: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cpu_limit: The maximum CPU limit for agent
        :param pulumi.Input[str] cpu_request: The minimum CPU required for agent
        :param pulumi.Input[str] memory_limit: The maximum memory limit for agent
        :param pulumi.Input[str] memory_request: The minimum memory required for agent
        """
        if cpu_limit is not None:
            pulumi.set(__self__, "cpu_limit", cpu_limit)
        if cpu_request is not None:
            pulumi.set(__self__, "cpu_request", cpu_request)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if memory_request is not None:
            pulumi.set(__self__, "memory_request", memory_request)

    @property
    @pulumi.getter(name="cpuLimit")
    def cpu_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

    @cpu_limit.setter
    def cpu_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_limit", value)

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

    @cpu_request.setter
    def cpu_request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_request", value)

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

    @memory_limit.setter
    def memory_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_limit", value)

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")

    @memory_request.setter
    def memory_request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_request", value)


@pulumi.input_type
class ClusterV2ClusterRegistrationTokenArgs:
    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,
                 insecure_node_command: Optional[pulumi.Input[str]] = None,
                 insecure_windows_node_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 the Cluster.
        :param pulumi.Input[str] id: (Computed, string) The ID of the resource.
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster.
        :param pulumi.Input[str] name: The name of the cluster.
        """
        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 insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_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 the Cluster.
        """
        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]]:
        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]]:
        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, string) The ID of the resource.
        """
        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]]:
        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(name="insecureNodeCommand")
    def insecure_node_command(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "insecure_node_command")

    @insecure_node_command.setter
    def insecure_node_command(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "insecure_node_command", value)

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "insecure_windows_node_command")

    @insecure_windows_node_command.setter
    def insecure_windows_node_command(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "insecure_windows_node_command", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster.
        """
        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]]:
        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]]:
        """
        The name of the cluster.
        """
        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]]:
        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]]:
        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]]:
        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 ClusterV2FleetAgentDeploymentCustomizationArgs:
    def __init__(__self__, *,
                 append_tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs']]]] = None,
                 override_affinity: Optional[pulumi.Input[str]] = None,
                 override_resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs']]] append_tolerations: User defined tolerations to append to agent
        :param pulumi.Input[str] override_affinity: User defined affinity to override default agent affinity
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]] override_resource_requirements: User defined resource requirements to set on the agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)

    @property
    @pulumi.getter(name="appendTolerations")
    def append_tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs']]]]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @append_tolerations.setter
    def append_tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs']]]]):
        pulumi.set(self, "append_tolerations", value)

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        User defined affinity to override default agent affinity
        """
        return pulumi.get(self, "override_affinity")

    @override_affinity.setter
    def override_affinity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "override_affinity", value)

    @property
    @pulumi.getter(name="overrideResourceRequirements")
    def override_resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]:
        """
        User defined resource requirements to set on the agent
        """
        return pulumi.get(self, "override_resource_requirements")

    @override_resource_requirements.setter
    def override_resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs']]]]):
        pulumi.set(self, "override_resource_requirements", value)


@pulumi.input_type
class ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 seconds: Optional[pulumi.Input[int]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "seconds", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs:
    def __init__(__self__, *,
                 cpu_limit: Optional[pulumi.Input[str]] = None,
                 cpu_request: Optional[pulumi.Input[str]] = None,
                 memory_limit: Optional[pulumi.Input[str]] = None,
                 memory_request: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cpu_limit: The maximum CPU limit for agent
        :param pulumi.Input[str] cpu_request: The minimum CPU required for agent
        :param pulumi.Input[str] memory_limit: The maximum memory limit for agent
        :param pulumi.Input[str] memory_request: The minimum memory required for agent
        """
        if cpu_limit is not None:
            pulumi.set(__self__, "cpu_limit", cpu_limit)
        if cpu_request is not None:
            pulumi.set(__self__, "cpu_request", cpu_request)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if memory_request is not None:
            pulumi.set(__self__, "memory_request", memory_request)

    @property
    @pulumi.getter(name="cpuLimit")
    def cpu_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

    @cpu_limit.setter
    def cpu_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_limit", value)

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

    @cpu_request.setter
    def cpu_request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_request", value)

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

    @memory_limit.setter
    def memory_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_limit", value)

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[pulumi.Input[str]]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")

    @memory_request.setter
    def memory_request(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory_request", value)


@pulumi.input_type
class ClusterV2LocalAuthEndpointArgs:
    def __init__(__self__, *,
                 ca_certs: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 fqdn: Optional[pulumi.Input[str]] = None):
        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]]:
        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 ClusterV2RkeConfigArgs:
    def __init__(__self__, *,
                 additional_manifest: Optional[pulumi.Input[str]] = None,
                 chart_values: Optional[pulumi.Input[str]] = None,
                 etcd: Optional[pulumi.Input['ClusterV2RkeConfigEtcdArgs']] = None,
                 etcd_snapshot_create: Optional[pulumi.Input['ClusterV2RkeConfigEtcdSnapshotCreateArgs']] = None,
                 etcd_snapshot_restore: Optional[pulumi.Input['ClusterV2RkeConfigEtcdSnapshotRestoreArgs']] = None,
                 local_auth_endpoint: Optional[pulumi.Input['ClusterV2RkeConfigLocalAuthEndpointArgs']] = None,
                 machine_global_config: Optional[pulumi.Input[str]] = None,
                 machine_pool_defaults: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolDefaultArgs']]]] = None,
                 machine_pools: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolArgs']]]] = None,
                 machine_selector_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigArgs']]]] = None,
                 machine_selector_files: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileArgs']]]] = None,
                 registries: Optional[pulumi.Input['ClusterV2RkeConfigRegistriesArgs']] = None,
                 rotate_certificates: Optional[pulumi.Input['ClusterV2RkeConfigRotateCertificatesArgs']] = None,
                 upgrade_strategy: Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyArgs']] = None):
        """
        :param pulumi.Input[str] additional_manifest: Cluster V2 additional manifest
        :param pulumi.Input[str] chart_values: Cluster V2 chart values. It should be in YAML format
        :param pulumi.Input['ClusterV2RkeConfigEtcdArgs'] etcd: Cluster V2 etcd
        :param pulumi.Input['ClusterV2RkeConfigEtcdSnapshotCreateArgs'] etcd_snapshot_create: Cluster V2 etcd snapshot create
        :param pulumi.Input['ClusterV2RkeConfigEtcdSnapshotRestoreArgs'] etcd_snapshot_restore: Cluster V2 etcd snapshot restore
        :param pulumi.Input['ClusterV2RkeConfigLocalAuthEndpointArgs'] local_auth_endpoint: Local auth endpoint configures the Authorized Cluster Endpoint (ACE) which can be used to directly access the Kubernetes API server, without requiring communication through Rancher. For more information, please refer to [Rancher Documentation](https://ranchermanager.docs.rancher.com/how-to-guides/new-user-guides/kubernetes-clusters-in-rancher-setup/register-existing-clusters#authorized-cluster-endpoint-support-for-rke2-and-k3s-clusters).
        :param pulumi.Input[str] machine_global_config: Cluster V2 machine global config
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolDefaultArgs']]] machine_pool_defaults: Default values for machine pool configurations if unset
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolArgs']]] machine_pools: Cluster V2 machine pools
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigArgs']]] machine_selector_configs: Cluster V2 machine selector config
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileArgs']]] machine_selector_files: Cluster V2 machine selector files
        :param pulumi.Input['ClusterV2RkeConfigRegistriesArgs'] registries: Cluster V2 registries
        :param pulumi.Input['ClusterV2RkeConfigRotateCertificatesArgs'] rotate_certificates: Cluster V2 certificate rotation
        :param pulumi.Input['ClusterV2RkeConfigUpgradeStrategyArgs'] upgrade_strategy: Cluster V2 upgrade strategy
        """
        if additional_manifest is not None:
            pulumi.set(__self__, "additional_manifest", additional_manifest)
        if chart_values is not None:
            pulumi.set(__self__, "chart_values", chart_values)
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if etcd_snapshot_create is not None:
            pulumi.set(__self__, "etcd_snapshot_create", etcd_snapshot_create)
        if etcd_snapshot_restore is not None:
            pulumi.set(__self__, "etcd_snapshot_restore", etcd_snapshot_restore)
        if local_auth_endpoint is not None:
            warnings.warn("""Use rancher2_cluster_v2.local_auth_endpoint instead""", DeprecationWarning)
            pulumi.log.warn("""local_auth_endpoint is deprecated: Use rancher2_cluster_v2.local_auth_endpoint instead""")
        if local_auth_endpoint is not None:
            pulumi.set(__self__, "local_auth_endpoint", local_auth_endpoint)
        if machine_global_config is not None:
            pulumi.set(__self__, "machine_global_config", machine_global_config)
        if machine_pool_defaults is not None:
            pulumi.set(__self__, "machine_pool_defaults", machine_pool_defaults)
        if machine_pools is not None:
            pulumi.set(__self__, "machine_pools", machine_pools)
        if machine_selector_configs is not None:
            pulumi.set(__self__, "machine_selector_configs", machine_selector_configs)
        if machine_selector_files is not None:
            pulumi.set(__self__, "machine_selector_files", machine_selector_files)
        if registries is not None:
            pulumi.set(__self__, "registries", registries)
        if rotate_certificates is not None:
            pulumi.set(__self__, "rotate_certificates", rotate_certificates)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter(name="additionalManifest")
    def additional_manifest(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster V2 additional manifest
        """
        return pulumi.get(self, "additional_manifest")

    @additional_manifest.setter
    def additional_manifest(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_manifest", value)

    @property
    @pulumi.getter(name="chartValues")
    def chart_values(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster V2 chart values. It should be in YAML format
        """
        return pulumi.get(self, "chart_values")

    @chart_values.setter
    def chart_values(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "chart_values", value)

    @property
    @pulumi.getter
    def etcd(self) -> Optional[pulumi.Input['ClusterV2RkeConfigEtcdArgs']]:
        """
        Cluster V2 etcd
        """
        return pulumi.get(self, "etcd")

    @etcd.setter
    def etcd(self, value: Optional[pulumi.Input['ClusterV2RkeConfigEtcdArgs']]):
        pulumi.set(self, "etcd", value)

    @property
    @pulumi.getter(name="etcdSnapshotCreate")
    def etcd_snapshot_create(self) -> Optional[pulumi.Input['ClusterV2RkeConfigEtcdSnapshotCreateArgs']]:
        """
        Cluster V2 etcd snapshot create
        """
        return pulumi.get(self, "etcd_snapshot_create")

    @etcd_snapshot_create.setter
    def etcd_snapshot_create(self, value: Optional[pulumi.Input['ClusterV2RkeConfigEtcdSnapshotCreateArgs']]):
        pulumi.set(self, "etcd_snapshot_create", value)

    @property
    @pulumi.getter(name="etcdSnapshotRestore")
    def etcd_snapshot_restore(self) -> Optional[pulumi.Input['ClusterV2RkeConfigEtcdSnapshotRestoreArgs']]:
        """
        Cluster V2 etcd snapshot restore
        """
        return pulumi.get(self, "etcd_snapshot_restore")

    @etcd_snapshot_restore.setter
    def etcd_snapshot_restore(self, value: Optional[pulumi.Input['ClusterV2RkeConfigEtcdSnapshotRestoreArgs']]):
        pulumi.set(self, "etcd_snapshot_restore", value)

    @property
    @pulumi.getter(name="localAuthEndpoint")
    def local_auth_endpoint(self) -> Optional[pulumi.Input['ClusterV2RkeConfigLocalAuthEndpointArgs']]:
        """
        Local auth endpoint configures the Authorized Cluster Endpoint (ACE) which can be used to directly access the Kubernetes API server, without requiring communication through Rancher. For more information, please refer to [Rancher Documentation](https://ranchermanager.docs.rancher.com/how-to-guides/new-user-guides/kubernetes-clusters-in-rancher-setup/register-existing-clusters#authorized-cluster-endpoint-support-for-rke2-and-k3s-clusters).
        """
        warnings.warn("""Use rancher2_cluster_v2.local_auth_endpoint instead""", DeprecationWarning)
        pulumi.log.warn("""local_auth_endpoint is deprecated: Use rancher2_cluster_v2.local_auth_endpoint instead""")

        return pulumi.get(self, "local_auth_endpoint")

    @local_auth_endpoint.setter
    def local_auth_endpoint(self, value: Optional[pulumi.Input['ClusterV2RkeConfigLocalAuthEndpointArgs']]):
        pulumi.set(self, "local_auth_endpoint", value)

    @property
    @pulumi.getter(name="machineGlobalConfig")
    def machine_global_config(self) -> Optional[pulumi.Input[str]]:
        """
        Cluster V2 machine global config
        """
        return pulumi.get(self, "machine_global_config")

    @machine_global_config.setter
    def machine_global_config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "machine_global_config", value)

    @property
    @pulumi.getter(name="machinePoolDefaults")
    def machine_pool_defaults(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolDefaultArgs']]]]:
        """
        Default values for machine pool configurations if unset
        """
        return pulumi.get(self, "machine_pool_defaults")

    @machine_pool_defaults.setter
    def machine_pool_defaults(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolDefaultArgs']]]]):
        pulumi.set(self, "machine_pool_defaults", value)

    @property
    @pulumi.getter(name="machinePools")
    def machine_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolArgs']]]]:
        """
        Cluster V2 machine pools
        """
        return pulumi.get(self, "machine_pools")

    @machine_pools.setter
    def machine_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolArgs']]]]):
        pulumi.set(self, "machine_pools", value)

    @property
    @pulumi.getter(name="machineSelectorConfigs")
    def machine_selector_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigArgs']]]]:
        """
        Cluster V2 machine selector config
        """
        return pulumi.get(self, "machine_selector_configs")

    @machine_selector_configs.setter
    def machine_selector_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigArgs']]]]):
        pulumi.set(self, "machine_selector_configs", value)

    @property
    @pulumi.getter(name="machineSelectorFiles")
    def machine_selector_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileArgs']]]]:
        """
        Cluster V2 machine selector files
        """
        return pulumi.get(self, "machine_selector_files")

    @machine_selector_files.setter
    def machine_selector_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileArgs']]]]):
        pulumi.set(self, "machine_selector_files", value)

    @property
    @pulumi.getter
    def registries(self) -> Optional[pulumi.Input['ClusterV2RkeConfigRegistriesArgs']]:
        """
        Cluster V2 registries
        """
        return pulumi.get(self, "registries")

    @registries.setter
    def registries(self, value: Optional[pulumi.Input['ClusterV2RkeConfigRegistriesArgs']]):
        pulumi.set(self, "registries", value)

    @property
    @pulumi.getter(name="rotateCertificates")
    def rotate_certificates(self) -> Optional[pulumi.Input['ClusterV2RkeConfigRotateCertificatesArgs']]:
        """
        Cluster V2 certificate rotation
        """
        return pulumi.get(self, "rotate_certificates")

    @rotate_certificates.setter
    def rotate_certificates(self, value: Optional[pulumi.Input['ClusterV2RkeConfigRotateCertificatesArgs']]):
        pulumi.set(self, "rotate_certificates", value)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyArgs']]:
        """
        Cluster V2 upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

    @upgrade_strategy.setter
    def upgrade_strategy(self, value: Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyArgs']]):
        pulumi.set(self, "upgrade_strategy", value)


@pulumi.input_type
class ClusterV2RkeConfigEtcdArgs:
    def __init__(__self__, *,
                 disable_snapshots: Optional[pulumi.Input[bool]] = None,
                 s3_config: Optional[pulumi.Input['ClusterV2RkeConfigEtcdS3ConfigArgs']] = None,
                 snapshot_retention: Optional[pulumi.Input[int]] = None,
                 snapshot_schedule_cron: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] disable_snapshots: Disable ETCD snapshots
        :param pulumi.Input['ClusterV2RkeConfigEtcdS3ConfigArgs'] s3_config: ETCD snapshot S3 config
        :param pulumi.Input[int] snapshot_retention: ETCD snapshot retention
        :param pulumi.Input[str] snapshot_schedule_cron: ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        if disable_snapshots is not None:
            pulumi.set(__self__, "disable_snapshots", disable_snapshots)
        if s3_config is not None:
            pulumi.set(__self__, "s3_config", s3_config)
        if snapshot_retention is not None:
            pulumi.set(__self__, "snapshot_retention", snapshot_retention)
        if snapshot_schedule_cron is not None:
            pulumi.set(__self__, "snapshot_schedule_cron", snapshot_schedule_cron)

    @property
    @pulumi.getter(name="disableSnapshots")
    def disable_snapshots(self) -> Optional[pulumi.Input[bool]]:
        """
        Disable ETCD snapshots
        """
        return pulumi.get(self, "disable_snapshots")

    @disable_snapshots.setter
    def disable_snapshots(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_snapshots", value)

    @property
    @pulumi.getter(name="s3Config")
    def s3_config(self) -> Optional[pulumi.Input['ClusterV2RkeConfigEtcdS3ConfigArgs']]:
        """
        ETCD snapshot S3 config
        """
        return pulumi.get(self, "s3_config")

    @s3_config.setter
    def s3_config(self, value: Optional[pulumi.Input['ClusterV2RkeConfigEtcdS3ConfigArgs']]):
        pulumi.set(self, "s3_config", value)

    @property
    @pulumi.getter(name="snapshotRetention")
    def snapshot_retention(self) -> Optional[pulumi.Input[int]]:
        """
        ETCD snapshot retention
        """
        return pulumi.get(self, "snapshot_retention")

    @snapshot_retention.setter
    def snapshot_retention(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "snapshot_retention", value)

    @property
    @pulumi.getter(name="snapshotScheduleCron")
    def snapshot_schedule_cron(self) -> Optional[pulumi.Input[str]]:
        """
        ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        return pulumi.get(self, "snapshot_schedule_cron")

    @snapshot_schedule_cron.setter
    def snapshot_schedule_cron(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "snapshot_schedule_cron", value)


@pulumi.input_type
class ClusterV2RkeConfigEtcdS3ConfigArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 endpoint: pulumi.Input[str],
                 cloud_credential_name: Optional[pulumi.Input[str]] = None,
                 endpoint_ca: Optional[pulumi.Input[str]] = None,
                 folder: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 skip_ssl_verify: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] bucket: ETCD snapshot S3 bucket
        :param pulumi.Input[str] endpoint: ETCD snapshot S3 endpoint
        :param pulumi.Input[str] cloud_credential_name: ETCD snapshot S3 cloud credential name
        :param pulumi.Input[str] endpoint_ca: ETCD snapshot S3 endpoint CA
        :param pulumi.Input[str] folder: ETCD snapshot S3 folder
        :param pulumi.Input[str] region: ETCD snapshot S3 region
        :param pulumi.Input[bool] skip_ssl_verify: Disable ETCD skip ssl verify
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "endpoint", endpoint)
        if cloud_credential_name is not None:
            pulumi.set(__self__, "cloud_credential_name", cloud_credential_name)
        if endpoint_ca is not None:
            pulumi.set(__self__, "endpoint_ca", endpoint_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if skip_ssl_verify is not None:
            pulumi.set(__self__, "skip_ssl_verify", skip_ssl_verify)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        """
        ETCD snapshot S3 bucket
        """
        return pulumi.get(self, "bucket")

    @bucket.setter
    def bucket(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket", value)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        ETCD snapshot S3 endpoint
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="cloudCredentialName")
    def cloud_credential_name(self) -> Optional[pulumi.Input[str]]:
        """
        ETCD snapshot S3 cloud credential name
        """
        return pulumi.get(self, "cloud_credential_name")

    @cloud_credential_name.setter
    def cloud_credential_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_credential_name", value)

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[pulumi.Input[str]]:
        """
        ETCD snapshot S3 endpoint CA
        """
        return pulumi.get(self, "endpoint_ca")

    @endpoint_ca.setter
    def endpoint_ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint_ca", value)

    @property
    @pulumi.getter
    def folder(self) -> Optional[pulumi.Input[str]]:
        """
        ETCD snapshot S3 folder
        """
        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]]:
        """
        ETCD snapshot S3 region
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[pulumi.Input[bool]]:
        """
        Disable ETCD skip ssl verify
        """
        return pulumi.get(self, "skip_ssl_verify")

    @skip_ssl_verify.setter
    def skip_ssl_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "skip_ssl_verify", value)


@pulumi.input_type
class ClusterV2RkeConfigEtcdSnapshotCreateArgs:
    def __init__(__self__, *,
                 generation: pulumi.Input[int]):
        """
        :param pulumi.Input[int] generation: ETCD generation to initiate a snapshot
        """
        pulumi.set(__self__, "generation", generation)

    @property
    @pulumi.getter
    def generation(self) -> pulumi.Input[int]:
        """
        ETCD generation to initiate a snapshot
        """
        return pulumi.get(self, "generation")

    @generation.setter
    def generation(self, value: pulumi.Input[int]):
        pulumi.set(self, "generation", value)


@pulumi.input_type
class ClusterV2RkeConfigEtcdSnapshotRestoreArgs:
    def __init__(__self__, *,
                 generation: pulumi.Input[int],
                 name: pulumi.Input[str],
                 restore_rke_config: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] generation: ETCD snapshot desired generation
        :param pulumi.Input[str] name: The name of the cluster.
        :param pulumi.Input[str] restore_rke_config: ETCD restore RKE config (set to none, all, or kubernetesVersion)
        """
        pulumi.set(__self__, "generation", generation)
        pulumi.set(__self__, "name", name)
        if restore_rke_config is not None:
            pulumi.set(__self__, "restore_rke_config", restore_rke_config)

    @property
    @pulumi.getter
    def generation(self) -> pulumi.Input[int]:
        """
        ETCD snapshot desired generation
        """
        return pulumi.get(self, "generation")

    @generation.setter
    def generation(self, value: pulumi.Input[int]):
        pulumi.set(self, "generation", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="restoreRkeConfig")
    def restore_rke_config(self) -> Optional[pulumi.Input[str]]:
        """
        ETCD restore RKE config (set to none, all, or kubernetesVersion)
        """
        return pulumi.get(self, "restore_rke_config")

    @restore_rke_config.setter
    def restore_rke_config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "restore_rke_config", value)


@pulumi.input_type
class ClusterV2RkeConfigLocalAuthEndpointArgs:
    def __init__(__self__, *,
                 ca_certs: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 fqdn: Optional[pulumi.Input[str]] = None):
        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]]:
        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 ClusterV2RkeConfigMachinePoolArgs:
    def __init__(__self__, *,
                 machine_config: pulumi.Input['ClusterV2RkeConfigMachinePoolMachineConfigArgs'],
                 name: pulumi.Input[str],
                 annotations: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 cloud_credential_secret_name: Optional[pulumi.Input[str]] = None,
                 control_plane_role: Optional[pulumi.Input[bool]] = None,
                 drain_before_delete: Optional[pulumi.Input[bool]] = None,
                 etcd_role: Optional[pulumi.Input[bool]] = None,
                 hostname_length_limit: Optional[pulumi.Input[int]] = None,
                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 machine_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 max_unhealthy: Optional[pulumi.Input[str]] = None,
                 node_drain_timeout: Optional[pulumi.Input[int]] = None,
                 node_startup_timeout_seconds: Optional[pulumi.Input[int]] = None,
                 paused: Optional[pulumi.Input[bool]] = None,
                 quantity: Optional[pulumi.Input[int]] = None,
                 rolling_update: Optional[pulumi.Input['ClusterV2RkeConfigMachinePoolRollingUpdateArgs']] = None,
                 taints: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolTaintArgs']]]] = None,
                 unhealthy_node_timeout_seconds: Optional[pulumi.Input[int]] = None,
                 unhealthy_range: Optional[pulumi.Input[str]] = None,
                 worker_role: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['ClusterV2RkeConfigMachinePoolMachineConfigArgs'] machine_config: Machine config data
        :param pulumi.Input[str] name: The name of the cluster.
        :param pulumi.Input[Mapping[str, Any]] annotations: Annotations for the Cluster.
        :param pulumi.Input[str] cloud_credential_secret_name: Cloud credential secret name is the secret to be used when a cloud credential secret name is not specified at the machine pool level.
        :param pulumi.Input[bool] control_plane_role: Machine pool control plane role
        :param pulumi.Input[bool] drain_before_delete: Machine pool drain before delete
        :param pulumi.Input[bool] etcd_role: Machine pool etcd role
        :param pulumi.Input[int] hostname_length_limit: maximum length for autogenerated hostname
        :param pulumi.Input[Mapping[str, Any]] labels: Labels for the Cluster.
        :param pulumi.Input[Mapping[str, Any]] machine_labels: Labels of the machine
        :param pulumi.Input[str] max_unhealthy: max unhealthy nodes for automated replacement to be allowed
        :param pulumi.Input[int] node_drain_timeout: seconds to wait for machine pool drain to complete before machine deletion
        :param pulumi.Input[int] node_startup_timeout_seconds: seconds a new node has to become active before it is replaced
        :param pulumi.Input[bool] paused: Machine pool paused
        :param pulumi.Input[int] quantity: Machine pool quantity
        :param pulumi.Input['ClusterV2RkeConfigMachinePoolRollingUpdateArgs'] rolling_update: Machine pool rolling update
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolTaintArgs']]] taints: Machine pool taints
        :param pulumi.Input[int] unhealthy_node_timeout_seconds: seconds an unhealthy node has to become active before it is replaced
        :param pulumi.Input[str] unhealthy_range: range of unhealthy nodes for automated replacement to be allowed
        :param pulumi.Input[bool] worker_role: Machine pool worker role
        """
        pulumi.set(__self__, "machine_config", machine_config)
        pulumi.set(__self__, "name", name)
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cloud_credential_secret_name is not None:
            pulumi.set(__self__, "cloud_credential_secret_name", cloud_credential_secret_name)
        if control_plane_role is not None:
            pulumi.set(__self__, "control_plane_role", control_plane_role)
        if drain_before_delete is not None:
            pulumi.set(__self__, "drain_before_delete", drain_before_delete)
        if etcd_role is not None:
            pulumi.set(__self__, "etcd_role", etcd_role)
        if hostname_length_limit is not None:
            pulumi.set(__self__, "hostname_length_limit", hostname_length_limit)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if machine_labels is not None:
            pulumi.set(__self__, "machine_labels", machine_labels)
        if max_unhealthy is not None:
            pulumi.set(__self__, "max_unhealthy", max_unhealthy)
        if node_drain_timeout is not None:
            pulumi.set(__self__, "node_drain_timeout", node_drain_timeout)
        if node_startup_timeout_seconds is not None:
            pulumi.set(__self__, "node_startup_timeout_seconds", node_startup_timeout_seconds)
        if paused is not None:
            pulumi.set(__self__, "paused", paused)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if unhealthy_node_timeout_seconds is not None:
            pulumi.set(__self__, "unhealthy_node_timeout_seconds", unhealthy_node_timeout_seconds)
        if unhealthy_range is not None:
            pulumi.set(__self__, "unhealthy_range", unhealthy_range)
        if worker_role is not None:
            pulumi.set(__self__, "worker_role", worker_role)

    @property
    @pulumi.getter(name="machineConfig")
    def machine_config(self) -> pulumi.Input['ClusterV2RkeConfigMachinePoolMachineConfigArgs']:
        """
        Machine config data
        """
        return pulumi.get(self, "machine_config")

    @machine_config.setter
    def machine_config(self, value: pulumi.Input['ClusterV2RkeConfigMachinePoolMachineConfigArgs']):
        pulumi.set(self, "machine_config", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the cluster.
        """
        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.
        """
        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="cloudCredentialSecretName")
    def cloud_credential_secret_name(self) -> Optional[pulumi.Input[str]]:
        """
        Cloud credential secret name is the secret to be used when a cloud credential secret name is not specified at the machine pool level.
        """
        return pulumi.get(self, "cloud_credential_secret_name")

    @cloud_credential_secret_name.setter
    def cloud_credential_secret_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_credential_secret_name", value)

    @property
    @pulumi.getter(name="controlPlaneRole")
    def control_plane_role(self) -> Optional[pulumi.Input[bool]]:
        """
        Machine pool control plane role
        """
        return pulumi.get(self, "control_plane_role")

    @control_plane_role.setter
    def control_plane_role(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "control_plane_role", value)

    @property
    @pulumi.getter(name="drainBeforeDelete")
    def drain_before_delete(self) -> Optional[pulumi.Input[bool]]:
        """
        Machine pool drain before delete
        """
        return pulumi.get(self, "drain_before_delete")

    @drain_before_delete.setter
    def drain_before_delete(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drain_before_delete", value)

    @property
    @pulumi.getter(name="etcdRole")
    def etcd_role(self) -> Optional[pulumi.Input[bool]]:
        """
        Machine pool etcd role
        """
        return pulumi.get(self, "etcd_role")

    @etcd_role.setter
    def etcd_role(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "etcd_role", value)

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[pulumi.Input[int]]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")

    @hostname_length_limit.setter
    def hostname_length_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "hostname_length_limit", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels for the Cluster.
        """
        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="machineLabels")
    def machine_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Labels of the machine
        """
        return pulumi.get(self, "machine_labels")

    @machine_labels.setter
    def machine_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "machine_labels", value)

    @property
    @pulumi.getter(name="maxUnhealthy")
    def max_unhealthy(self) -> Optional[pulumi.Input[str]]:
        """
        max unhealthy nodes for automated replacement to be allowed
        """
        return pulumi.get(self, "max_unhealthy")

    @max_unhealthy.setter
    def max_unhealthy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_unhealthy", value)

    @property
    @pulumi.getter(name="nodeDrainTimeout")
    def node_drain_timeout(self) -> Optional[pulumi.Input[int]]:
        """
        seconds to wait for machine pool drain to complete before machine deletion
        """
        return pulumi.get(self, "node_drain_timeout")

    @node_drain_timeout.setter
    def node_drain_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "node_drain_timeout", value)

    @property
    @pulumi.getter(name="nodeStartupTimeoutSeconds")
    def node_startup_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        seconds a new node has to become active before it is replaced
        """
        return pulumi.get(self, "node_startup_timeout_seconds")

    @node_startup_timeout_seconds.setter
    def node_startup_timeout_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "node_startup_timeout_seconds", value)

    @property
    @pulumi.getter
    def paused(self) -> Optional[pulumi.Input[bool]]:
        """
        Machine pool paused
        """
        return pulumi.get(self, "paused")

    @paused.setter
    def paused(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "paused", value)

    @property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[int]]:
        """
        Machine pool quantity
        """
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "quantity", value)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional[pulumi.Input['ClusterV2RkeConfigMachinePoolRollingUpdateArgs']]:
        """
        Machine pool rolling update
        """
        return pulumi.get(self, "rolling_update")

    @rolling_update.setter
    def rolling_update(self, value: Optional[pulumi.Input['ClusterV2RkeConfigMachinePoolRollingUpdateArgs']]):
        pulumi.set(self, "rolling_update", value)

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolTaintArgs']]]]:
        """
        Machine pool taints
        """
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachinePoolTaintArgs']]]]):
        pulumi.set(self, "taints", value)

    @property
    @pulumi.getter(name="unhealthyNodeTimeoutSeconds")
    def unhealthy_node_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        seconds an unhealthy node has to become active before it is replaced
        """
        return pulumi.get(self, "unhealthy_node_timeout_seconds")

    @unhealthy_node_timeout_seconds.setter
    def unhealthy_node_timeout_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "unhealthy_node_timeout_seconds", value)

    @property
    @pulumi.getter(name="unhealthyRange")
    def unhealthy_range(self) -> Optional[pulumi.Input[str]]:
        """
        range of unhealthy nodes for automated replacement to be allowed
        """
        return pulumi.get(self, "unhealthy_range")

    @unhealthy_range.setter
    def unhealthy_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "unhealthy_range", value)

    @property
    @pulumi.getter(name="workerRole")
    def worker_role(self) -> Optional[pulumi.Input[bool]]:
        """
        Machine pool worker role
        """
        return pulumi.get(self, "worker_role")

    @worker_role.setter
    def worker_role(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "worker_role", value)


@pulumi.input_type
class ClusterV2RkeConfigMachinePoolDefaultArgs:
    def __init__(__self__, *,
                 hostname_length_limit: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] hostname_length_limit: maximum length for autogenerated hostname
        """
        if hostname_length_limit is not None:
            pulumi.set(__self__, "hostname_length_limit", hostname_length_limit)

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[pulumi.Input[int]]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")

    @hostname_length_limit.setter
    def hostname_length_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "hostname_length_limit", value)


@pulumi.input_type
class ClusterV2RkeConfigMachinePoolMachineConfigArgs:
    def __init__(__self__, *,
                 kind: pulumi.Input[str],
                 name: pulumi.Input[str],
                 api_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kind: Machine config kind
        :param pulumi.Input[str] name: The name of the cluster.
        :param pulumi.Input[str] api_version: Machine config API version
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "name", name)
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)

    @property
    @pulumi.getter
    def kind(self) -> pulumi.Input[str]:
        """
        Machine config kind
        """
        return pulumi.get(self, "kind")

    @kind.setter
    def kind(self, value: pulumi.Input[str]):
        pulumi.set(self, "kind", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[pulumi.Input[str]]:
        """
        Machine config API version
        """
        return pulumi.get(self, "api_version")

    @api_version.setter
    def api_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_version", value)


@pulumi.input_type
class ClusterV2RkeConfigMachinePoolRollingUpdateArgs:
    def __init__(__self__, *,
                 max_surge: Optional[pulumi.Input[str]] = None,
                 max_unavailable: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] max_surge: Rolling update max surge
        :param pulumi.Input[str] max_unavailable: Rolling update max unavailable
        """
        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[str]]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_surge", value)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[str]]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_unavailable", value)


@pulumi.input_type
class ClusterV2RkeConfigMachinePoolTaintArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        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]:
        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]]:
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "effect", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorConfigArgs:
    def __init__(__self__, *,
                 config: Optional[pulumi.Input[str]] = None,
                 machine_label_selector: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs']] = None):
        """
        :param pulumi.Input[str] config: Machine selector config
        :param pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs'] machine_label_selector: Machine label selector
        """
        if config is not None:
            pulumi.set(__self__, "config", config)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input[str]]:
        """
        Machine selector config
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs']]:
        """
        Machine label selector
        """
        return pulumi.get(self, "machine_label_selector")

    @machine_label_selector.setter
    def machine_label_selector(self, value: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs']]):
        pulumi.set(self, "machine_label_selector", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs']]]] = None,
                 match_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs']]] match_expressions: Label selector match expressions
        :param pulumi.Input[Mapping[str, Any]] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs']]]]:
        """
        Label selector match expressions
        """
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")

    @match_labels.setter
    def match_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "match_labels", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] key: Label selector requirement key
        :param pulumi.Input[str] operator: Label selector operator
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Label selector requirement values
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Label selector requirement values
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileArgs:
    def __init__(__self__, *,
                 file_sources: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceArgs']]]] = None,
                 machine_label_selector: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceArgs']]] file_sources: File sources
        :param pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs'] machine_label_selector: Machine label selector
        """
        if file_sources is not None:
            pulumi.set(__self__, "file_sources", file_sources)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

    @property
    @pulumi.getter(name="fileSources")
    def file_sources(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceArgs']]]]:
        """
        File sources
        """
        return pulumi.get(self, "file_sources")

    @file_sources.setter
    def file_sources(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceArgs']]]]):
        pulumi.set(self, "file_sources", value)

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs']]:
        """
        Machine label selector
        """
        return pulumi.get(self, "machine_label_selector")

    @machine_label_selector.setter
    def machine_label_selector(self, value: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs']]):
        pulumi.set(self, "machine_label_selector", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceArgs:
    def __init__(__self__, *,
                 configmap: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs']] = None,
                 secret: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs']] = None):
        """
        :param pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs'] configmap: The configmap which is the source of files
        :param pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs'] secret: The secret which is the source of files
        """
        if configmap is not None:
            pulumi.set(__self__, "configmap", configmap)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def configmap(self) -> Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs']]:
        """
        The configmap which is the source of files
        """
        return pulumi.get(self, "configmap")

    @configmap.setter
    def configmap(self, value: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs']]):
        pulumi.set(self, "configmap", value)

    @property
    @pulumi.getter
    def secret(self) -> Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs']]:
        """
        The secret which is the source of files
        """
        return pulumi.get(self, "secret")

    @secret.setter
    def secret(self, value: Optional[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs']]):
        pulumi.set(self, "secret", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 default_permissions: Optional[pulumi.Input[str]] = None,
                 items: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs']]]] = None):
        """
        :param pulumi.Input[str] name: The name of the cluster.
        :param pulumi.Input[str] default_permissions: The default permissions to be applied when they are not set at the item level
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs']]] items: Items(files) to retrieve from the K8s object
        """
        pulumi.set(__self__, "name", name)
        if default_permissions is not None:
            pulumi.set(__self__, "default_permissions", default_permissions)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[pulumi.Input[str]]:
        """
        The default permissions to be applied when they are not set at the item level
        """
        return pulumi.get(self, "default_permissions")

    @default_permissions.setter
    def default_permissions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_permissions", value)

    @property
    @pulumi.getter
    def items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs']]]]:
        """
        Items(files) to retrieve from the K8s object
        """
        return pulumi.get(self, "items")

    @items.setter
    def items(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs']]]]):
        pulumi.set(self, "items", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 path: pulumi.Input[str],
                 dynamic: Optional[pulumi.Input[bool]] = None,
                 hash: Optional[pulumi.Input[str]] = None,
                 permissions: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: The key of the item(file) to retrieve
        :param pulumi.Input[str] path: The path to put the file in the target node
        :param pulumi.Input[bool] dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param pulumi.Input[str] hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param pulumi.Input[str] permissions: The numeric representation of the file permissions
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        if dynamic is not None:
            pulumi.set(__self__, "dynamic", dynamic)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[pulumi.Input[bool]]:
        """
        If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        """
        return pulumi.get(self, "dynamic")

    @dynamic.setter
    def dynamic(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dynamic", value)

    @property
    @pulumi.getter
    def hash(self) -> Optional[pulumi.Input[str]]:
        """
        The base64 encoded value of the SHA256 checksum of the file's content
        """
        return pulumi.get(self, "hash")

    @hash.setter
    def hash(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hash", value)

    @property
    @pulumi.getter
    def permissions(self) -> Optional[pulumi.Input[str]]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")

    @permissions.setter
    def permissions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "permissions", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 default_permissions: Optional[pulumi.Input[str]] = None,
                 items: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs']]]] = None):
        """
        :param pulumi.Input[str] name: The name of the cluster.
        :param pulumi.Input[str] default_permissions: The default permissions to be applied when they are not set at the item level
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs']]] items: Items(files) to retrieve from the K8s object
        """
        pulumi.set(__self__, "name", name)
        if default_permissions is not None:
            pulumi.set(__self__, "default_permissions", default_permissions)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[pulumi.Input[str]]:
        """
        The default permissions to be applied when they are not set at the item level
        """
        return pulumi.get(self, "default_permissions")

    @default_permissions.setter
    def default_permissions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_permissions", value)

    @property
    @pulumi.getter
    def items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs']]]]:
        """
        Items(files) to retrieve from the K8s object
        """
        return pulumi.get(self, "items")

    @items.setter
    def items(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs']]]]):
        pulumi.set(self, "items", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 path: pulumi.Input[str],
                 dynamic: Optional[pulumi.Input[bool]] = None,
                 hash: Optional[pulumi.Input[str]] = None,
                 permissions: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: The key of the item(file) to retrieve
        :param pulumi.Input[str] path: The path to put the file in the target node
        :param pulumi.Input[bool] dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param pulumi.Input[str] hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param pulumi.Input[str] permissions: The numeric representation of the file permissions
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        if dynamic is not None:
            pulumi.set(__self__, "dynamic", dynamic)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[pulumi.Input[bool]]:
        """
        If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        """
        return pulumi.get(self, "dynamic")

    @dynamic.setter
    def dynamic(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dynamic", value)

    @property
    @pulumi.getter
    def hash(self) -> Optional[pulumi.Input[str]]:
        """
        The base64 encoded value of the SHA256 checksum of the file's content
        """
        return pulumi.get(self, "hash")

    @hash.setter
    def hash(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hash", value)

    @property
    @pulumi.getter
    def permissions(self) -> Optional[pulumi.Input[str]]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")

    @permissions.setter
    def permissions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "permissions", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs:
    def __init__(__self__, *,
                 match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs']]]] = None,
                 match_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs']]] match_expressions: Label selector match expressions
        :param pulumi.Input[Mapping[str, Any]] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs']]]]:
        """
        Label selector match expressions
        """
        return pulumi.get(self, "match_expressions")

    @match_expressions.setter
    def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs']]]]):
        pulumi.set(self, "match_expressions", value)

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")

    @match_labels.setter
    def match_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "match_labels", value)


@pulumi.input_type
class ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 operator: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] key: Label selector requirement key
        :param pulumi.Input[str] operator: Label selector operator
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Label selector requirement values
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[str]]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operator", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Label selector requirement values
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class ClusterV2RkeConfigRegistriesArgs:
    def __init__(__self__, *,
                 configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesConfigArgs']]]] = None,
                 mirrors: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesMirrorArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesConfigArgs']]] configs: Registry config
        :param pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesMirrorArgs']]] mirrors: Registry mirrors
        """
        if configs is not None:
            pulumi.set(__self__, "configs", configs)
        if mirrors is not None:
            pulumi.set(__self__, "mirrors", mirrors)

    @property
    @pulumi.getter
    def configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesConfigArgs']]]]:
        """
        Registry config
        """
        return pulumi.get(self, "configs")

    @configs.setter
    def configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesConfigArgs']]]]):
        pulumi.set(self, "configs", value)

    @property
    @pulumi.getter
    def mirrors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesMirrorArgs']]]]:
        """
        Registry mirrors
        """
        return pulumi.get(self, "mirrors")

    @mirrors.setter
    def mirrors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterV2RkeConfigRegistriesMirrorArgs']]]]):
        pulumi.set(self, "mirrors", value)


@pulumi.input_type
class ClusterV2RkeConfigRegistriesConfigArgs:
    def __init__(__self__, *,
                 hostname: pulumi.Input[str],
                 auth_config_secret_name: Optional[pulumi.Input[str]] = None,
                 ca_bundle: Optional[pulumi.Input[str]] = None,
                 insecure: Optional[pulumi.Input[bool]] = None,
                 tls_secret_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] hostname: Registry hostname
        :param pulumi.Input[str] auth_config_secret_name: Registry auth config secret name
        :param pulumi.Input[str] ca_bundle: Registry CA bundle
        :param pulumi.Input[bool] insecure: Registry insecure connectivity
        :param pulumi.Input[str] tls_secret_name: Registry TLS secret name. TLS is a pair of Cert/Key
        """
        pulumi.set(__self__, "hostname", hostname)
        if auth_config_secret_name is not None:
            pulumi.set(__self__, "auth_config_secret_name", auth_config_secret_name)
        if ca_bundle is not None:
            pulumi.set(__self__, "ca_bundle", ca_bundle)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if tls_secret_name is not None:
            pulumi.set(__self__, "tls_secret_name", tls_secret_name)

    @property
    @pulumi.getter
    def hostname(self) -> pulumi.Input[str]:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: pulumi.Input[str]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter(name="authConfigSecretName")
    def auth_config_secret_name(self) -> Optional[pulumi.Input[str]]:
        """
        Registry auth config secret name
        """
        return pulumi.get(self, "auth_config_secret_name")

    @auth_config_secret_name.setter
    def auth_config_secret_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_config_secret_name", value)

    @property
    @pulumi.getter(name="caBundle")
    def ca_bundle(self) -> Optional[pulumi.Input[str]]:
        """
        Registry CA bundle
        """
        return pulumi.get(self, "ca_bundle")

    @ca_bundle.setter
    def ca_bundle(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_bundle", value)

    @property
    @pulumi.getter
    def insecure(self) -> Optional[pulumi.Input[bool]]:
        """
        Registry insecure connectivity
        """
        return pulumi.get(self, "insecure")

    @insecure.setter
    def insecure(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "insecure", value)

    @property
    @pulumi.getter(name="tlsSecretName")
    def tls_secret_name(self) -> Optional[pulumi.Input[str]]:
        """
        Registry TLS secret name. TLS is a pair of Cert/Key
        """
        return pulumi.get(self, "tls_secret_name")

    @tls_secret_name.setter
    def tls_secret_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tls_secret_name", value)


@pulumi.input_type
class ClusterV2RkeConfigRegistriesMirrorArgs:
    def __init__(__self__, *,
                 hostname: pulumi.Input[str],
                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 rewrites: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[str] hostname: Registry hostname
        :param pulumi.Input[Sequence[pulumi.Input[str]]] endpoints: Registry mirror endpoints
        :param pulumi.Input[Mapping[str, Any]] rewrites: Registry mirror rewrites
        """
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

    @property
    @pulumi.getter
    def hostname(self) -> pulumi.Input[str]:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: pulumi.Input[str]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Registry mirror endpoints
        """
        return pulumi.get(self, "endpoints")

    @endpoints.setter
    def endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "endpoints", value)

    @property
    @pulumi.getter
    def rewrites(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Registry mirror rewrites
        """
        return pulumi.get(self, "rewrites")

    @rewrites.setter
    def rewrites(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "rewrites", value)


@pulumi.input_type
class ClusterV2RkeConfigRotateCertificatesArgs:
    def __init__(__self__, *,
                 generation: pulumi.Input[int],
                 services: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] generation: Desired certificate rotation generation.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] services: Service certificates to rotate with this generation.
        """
        pulumi.set(__self__, "generation", generation)
        if services is not None:
            pulumi.set(__self__, "services", services)

    @property
    @pulumi.getter
    def generation(self) -> pulumi.Input[int]:
        """
        Desired certificate rotation generation.
        """
        return pulumi.get(self, "generation")

    @generation.setter
    def generation(self, value: pulumi.Input[int]):
        pulumi.set(self, "generation", value)

    @property
    @pulumi.getter
    def services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Service certificates to rotate with this generation.
        """
        return pulumi.get(self, "services")

    @services.setter
    def services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "services", value)


@pulumi.input_type
class ClusterV2RkeConfigUpgradeStrategyArgs:
    def __init__(__self__, *,
                 control_plane_concurrency: Optional[pulumi.Input[str]] = None,
                 control_plane_drain_options: Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs']] = None,
                 worker_concurrency: Optional[pulumi.Input[str]] = None,
                 worker_drain_options: Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs']] = None):
        """
        :param pulumi.Input[str] control_plane_concurrency: How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        :param pulumi.Input['ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs'] control_plane_drain_options: Controlplane nodes drain options
        :param pulumi.Input[str] worker_concurrency: How many worker nodes should be upgrade at time
        :param pulumi.Input['ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs'] worker_drain_options: Worker nodes drain options
        """
        if control_plane_concurrency is not None:
            pulumi.set(__self__, "control_plane_concurrency", control_plane_concurrency)
        if control_plane_drain_options is not None:
            pulumi.set(__self__, "control_plane_drain_options", control_plane_drain_options)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)
        if worker_drain_options is not None:
            pulumi.set(__self__, "worker_drain_options", worker_drain_options)

    @property
    @pulumi.getter(name="controlPlaneConcurrency")
    def control_plane_concurrency(self) -> Optional[pulumi.Input[str]]:
        """
        How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        """
        return pulumi.get(self, "control_plane_concurrency")

    @control_plane_concurrency.setter
    def control_plane_concurrency(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "control_plane_concurrency", value)

    @property
    @pulumi.getter(name="controlPlaneDrainOptions")
    def control_plane_drain_options(self) -> Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs']]:
        """
        Controlplane nodes drain options
        """
        return pulumi.get(self, "control_plane_drain_options")

    @control_plane_drain_options.setter
    def control_plane_drain_options(self, value: Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs']]):
        pulumi.set(self, "control_plane_drain_options", value)

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[pulumi.Input[str]]:
        """
        How many worker nodes should be upgrade at time
        """
        return pulumi.get(self, "worker_concurrency")

    @worker_concurrency.setter
    def worker_concurrency(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "worker_concurrency", value)

    @property
    @pulumi.getter(name="workerDrainOptions")
    def worker_drain_options(self) -> Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs']]:
        """
        Worker nodes drain options
        """
        return pulumi.get(self, "worker_drain_options")

    @worker_drain_options.setter
    def worker_drain_options(self, value: Optional[pulumi.Input['ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs']]):
        pulumi.set(self, "worker_drain_options", value)


@pulumi.input_type
class ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs:
    def __init__(__self__, *,
                 delete_empty_dir_data: Optional[pulumi.Input[bool]] = None,
                 disable_eviction: Optional[pulumi.Input[bool]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 grace_period: Optional[pulumi.Input[int]] = None,
                 ignore_daemon_sets: Optional[pulumi.Input[bool]] = None,
                 ignore_errors: Optional[pulumi.Input[bool]] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[pulumi.Input[int]] = None,
                 timeout: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] delete_empty_dir_data: Drain options delete empty dir data
        :param pulumi.Input[bool] disable_eviction: Drain options disable eviction
        :param pulumi.Input[bool] enabled: Drain options enabled?
        :param pulumi.Input[bool] force: Drain options force
        :param pulumi.Input[int] grace_period: Drain options grace period
        :param pulumi.Input[bool] ignore_daemon_sets: Drain options ignore daemon sets
        :param pulumi.Input[bool] ignore_errors: Drain options ignore errors
        :param pulumi.Input[int] skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param pulumi.Input[int] timeout: Drain options timeout
        """
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        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 ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)
        if skip_wait_for_delete_timeout_seconds is not None:
            pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options delete empty dir data
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @delete_empty_dir_data.setter
    def delete_empty_dir_data(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "delete_empty_dir_data", value)

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @disable_eviction.setter
    def disable_eviction(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_eviction", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def force(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options force
        """
        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[int]]:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @grace_period.setter
    def grace_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "grace_period", value)

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options ignore daemon sets
        """
        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(name="ignoreErrors")
    def ignore_errors(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")

    @ignore_errors.setter
    def ignore_errors(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_errors", value)

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Drain options skip wait for delete timeout seconds
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

    @skip_wait_for_delete_timeout_seconds.setter
    def skip_wait_for_delete_timeout_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "skip_wait_for_delete_timeout_seconds", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[int]]:
        """
        Drain options timeout
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs:
    def __init__(__self__, *,
                 delete_empty_dir_data: Optional[pulumi.Input[bool]] = None,
                 disable_eviction: Optional[pulumi.Input[bool]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 grace_period: Optional[pulumi.Input[int]] = None,
                 ignore_daemon_sets: Optional[pulumi.Input[bool]] = None,
                 ignore_errors: Optional[pulumi.Input[bool]] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[pulumi.Input[int]] = None,
                 timeout: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] delete_empty_dir_data: Drain options delete empty dir data
        :param pulumi.Input[bool] disable_eviction: Drain options disable eviction
        :param pulumi.Input[bool] enabled: Drain options enabled?
        :param pulumi.Input[bool] force: Drain options force
        :param pulumi.Input[int] grace_period: Drain options grace period
        :param pulumi.Input[bool] ignore_daemon_sets: Drain options ignore daemon sets
        :param pulumi.Input[bool] ignore_errors: Drain options ignore errors
        :param pulumi.Input[int] skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param pulumi.Input[int] timeout: Drain options timeout
        """
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        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 ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)
        if skip_wait_for_delete_timeout_seconds is not None:
            pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options delete empty dir data
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @delete_empty_dir_data.setter
    def delete_empty_dir_data(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "delete_empty_dir_data", value)

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @disable_eviction.setter
    def disable_eviction(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_eviction", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def force(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options force
        """
        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[int]]:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @grace_period.setter
    def grace_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "grace_period", value)

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options ignore daemon sets
        """
        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(name="ignoreErrors")
    def ignore_errors(self) -> Optional[pulumi.Input[bool]]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")

    @ignore_errors.setter
    def ignore_errors(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_errors", value)

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Drain options skip wait for delete timeout seconds
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

    @skip_wait_for_delete_timeout_seconds.setter
    def skip_wait_for_delete_timeout_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "skip_wait_for_delete_timeout_seconds", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[int]]:
        """
        Drain options timeout
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class EtcdBackupBackupConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 interval_hours: Optional[pulumi.Input[int]] = None,
                 retention: Optional[pulumi.Input[int]] = None,
                 s3_backup_config: Optional[pulumi.Input['EtcdBackupBackupConfigS3BackupConfigArgs']] = None,
                 safe_timestamp: Optional[pulumi.Input[bool]] = None,
                 timeout: Optional[pulumi.Input[int]] = None):
        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)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[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[int]]:
        return pulumi.get(self, "interval_hours")

    @interval_hours.setter
    def interval_hours(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interval_hours", value)

    @property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retention", value)

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional[pulumi.Input['EtcdBackupBackupConfigS3BackupConfigArgs']]:
        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)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timeout", 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):
        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 GlobalDnsProviderAlidnsConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 secret_key: pulumi.Input[str]):
        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]:
        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]:
        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 GlobalDnsProviderCloudflareConfigArgs:
    def __init__(__self__, *,
                 api_email: pulumi.Input[str],
                 api_key: pulumi.Input[str],
                 proxy_setting: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "api_email", api_email)
        pulumi.set(__self__, "api_key", api_key)
        if proxy_setting is not None:
            pulumi.set(__self__, "proxy_setting", proxy_setting)

    @property
    @pulumi.getter(name="apiEmail")
    def api_email(self) -> pulumi.Input[str]:
        return pulumi.get(self, "api_email")

    @api_email.setter
    def api_email(self, value: pulumi.Input[str]):
        pulumi.set(self, "api_email", value)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "api_key")

    @api_key.setter
    def api_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "api_key", value)

    @property
    @pulumi.getter(name="proxySetting")
    def proxy_setting(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "proxy_setting")

    @proxy_setting.setter
    def proxy_setting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "proxy_setting", value)


@pulumi.input_type
class GlobalDnsProviderRoute53ConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 secret_key: pulumi.Input[str],
                 credentials_path: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 zone_type: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if credentials_path is not None:
            pulumi.set(__self__, "credentials_path", credentials_path)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if zone_type is not None:
            pulumi.set(__self__, "zone_type", zone_type)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        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]:
        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(name="credentialsPath")
    def credentials_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "credentials_path")

    @credentials_path.setter
    def credentials_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "credentials_path", 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="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="zoneType")
    def zone_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "zone_type")

    @zone_type.setter
    def zone_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone_type", value)


@pulumi.input_type
class GlobalRoleRuleArgs:
    def __init__(__self__, *,
                 api_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 non_resource_urls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resource_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resources: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 verbs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] api_groups: Policy rule api groups
        :param pulumi.Input[Sequence[pulumi.Input[str]]] non_resource_urls: Policy rule non resource urls
        :param pulumi.Input[Sequence[pulumi.Input[str]]] resource_names: Policy rule resource names
        :param pulumi.Input[Sequence[pulumi.Input[str]]] resources: Policy rule resources
        :param pulumi.Input[Sequence[pulumi.Input[str]]] verbs: Policy rule verbs
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @api_groups.setter
    def api_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "api_groups", value)

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @non_resource_urls.setter
    def non_resource_urls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "non_resource_urls", value)

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @resource_names.setter
    def resource_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "resource_names", value)

    @property
    @pulumi.getter
    def resources(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @resources.setter
    def resources(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "resources", value)

    @property
    @pulumi.getter
    def verbs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")

    @verbs.setter
    def verbs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "verbs", value)


@pulumi.input_type
class MachineConfigV2Amazonec2ConfigArgs:
    def __init__(__self__, *,
                 ami: pulumi.Input[str],
                 region: pulumi.Input[str],
                 security_groups: pulumi.Input[Sequence[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,
                 http_endpoint: Optional[pulumi.Input[str]] = None,
                 http_tokens: 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,
                 kms_key: Optional[pulumi.Input[str]] = None,
                 monitoring: Optional[pulumi.Input[bool]] = None,
                 open_ports: Optional[pulumi.Input[Sequence[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_key_contents: 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
        :param pulumi.Input[str] region: AWS Region
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: AWS VPC security group
        :param pulumi.Input[str] subnet_id: AWS VPC subnet id
        :param pulumi.Input[str] vpc_id: AWS VPC id
        :param pulumi.Input[str] zone: AWS zone for instance (i.e. a,b,c,d,e)
        :param pulumi.Input[str] access_key: AWS Access Key
        :param pulumi.Input[str] block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        :param pulumi.Input[str] device_name: AWS root device name
        :param pulumi.Input[bool] encrypt_ebs_volume: Encrypt EBS volume
        :param pulumi.Input[str] endpoint: Optional endpoint URL (hostname only or fully qualified URI)
        :param pulumi.Input[str] http_endpoint: Enables or disables the HTTP metadata endpoint on your instances
        :param pulumi.Input[str] http_tokens: The state of token usage for your instance metadata requests
        :param pulumi.Input[str] iam_instance_profile: AWS IAM Instance Profile
        :param pulumi.Input[bool] insecure_transport: Disable SSL when sending requests
        :param pulumi.Input[str] instance_type: AWS instance type
        :param pulumi.Input[str] kms_key: Custom KMS key ID using the AWS Managed CMK
        :param pulumi.Input[bool] monitoring: Set this flag to enable CloudWatch monitoring
        :param pulumi.Input[Sequence[pulumi.Input[str]]] open_ports: Make the specified port number accessible from the Internet
        :param pulumi.Input[bool] private_address_only: Only use a private IP address
        :param pulumi.Input[bool] request_spot_instance: Set this flag to request spot instance
        :param pulumi.Input[str] retries: Set retry count for recoverable failures (use -1 to disable)
        :param pulumi.Input[str] root_size: AWS root disk size (in GB)
        :param pulumi.Input[str] secret_key: AWS Secret Key
        :param pulumi.Input[bool] security_group_readonly: Skip adding default rules to security groups
        :param pulumi.Input[str] session_token: AWS Session Token
        :param pulumi.Input[str] spot_price: AWS spot instance bid price (in dollar)
        :param pulumi.Input[str] ssh_key_contents: SSH Key file contents for sshKeyContents
        :param pulumi.Input[str] ssh_user: Set the name of the ssh user
        :param pulumi.Input[str] tags: AWS Tags (e.g. key1,value1,key2,value2)
        :param pulumi.Input[bool] use_ebs_optimized_instance: Create an EBS optimized instance
        :param pulumi.Input[bool] use_private_address: Force the usage of private IP address
        :param pulumi.Input[str] userdata: Path to file with cloud-init user data
        :param pulumi.Input[str] volume_type: Amazon EBS volume type
        """
        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 http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if http_tokens is not None:
            pulumi.set(__self__, "http_tokens", http_tokens)
        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 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_key_contents is not None:
            pulumi.set(__self__, "ssh_key_contents", ssh_key_contents)
        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
        """
        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]:
        """
        AWS Region
        """
        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[Sequence[pulumi.Input[str]]]:
        """
        AWS VPC security group
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: pulumi.Input[Sequence[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
        """
        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
        """
        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)
        """
        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
        """
        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)
        """
        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
        """
        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
        """
        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)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="httpEndpoint")
    def http_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Enables or disables the HTTP metadata endpoint on your instances
        """
        return pulumi.get(self, "http_endpoint")

    @http_endpoint.setter
    def http_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_endpoint", value)

    @property
    @pulumi.getter(name="httpTokens")
    def http_tokens(self) -> Optional[pulumi.Input[str]]:
        """
        The state of token usage for your instance metadata requests
        """
        return pulumi.get(self, "http_tokens")

    @http_tokens.setter
    def http_tokens(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_tokens", value)

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
        """
        AWS IAM Instance Profile
        """
        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
        """
        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]]:
        """
        AWS instance type
        """
        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="kmsKey")
    def kms_key(self) -> Optional[pulumi.Input[str]]:
        """
        Custom KMS key ID using the AWS Managed CMK
        """
        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]]:
        """
        Set this flag to enable CloudWatch monitoring
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @open_ports.setter
    def open_ports(self, value: Optional[pulumi.Input[Sequence[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
        """
        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
        """
        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)
        """
        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)
        """
        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
        """
        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
        """
        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
        """
        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)
        """
        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="sshKeyContents")
    def ssh_key_contents(self) -> Optional[pulumi.Input[str]]:
        """
        SSH Key file contents for sshKeyContents
        """
        return pulumi.get(self, "ssh_key_contents")

    @ssh_key_contents.setter
    def ssh_key_contents(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_contents", value)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[pulumi.Input[str]]:
        """
        Set the name of the ssh user
        """
        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]]:
        """
        AWS Tags (e.g. key1,value1,key2,value2)
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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 MachineConfigV2AzureConfigArgs:
    def __init__(__self__, *,
                 accelerated_networking: Optional[pulumi.Input[bool]] = None,
                 availability_set: Optional[pulumi.Input[str]] = None,
                 availability_zone: 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[Sequence[pulumi.Input[str]]]] = None,
                 private_address_only: Optional[pulumi.Input[bool]] = 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,
                 tags: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None,
                 update_domain_count: Optional[pulumi.Input[str]] = None,
                 use_private_ip: Optional[pulumi.Input[bool]] = None,
                 use_public_ip_standard_sku: Optional[pulumi.Input[bool]] = None,
                 vnet: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] accelerated_networking: Use Accelerated Networking when creating a network interface for the Azure VM
        :param pulumi.Input[str] availability_set: Azure Availability Set to place the virtual machine into
        :param pulumi.Input[str] availability_zone: The Availability Zone that the Azure VM should be created in
        :param pulumi.Input[str] client_id: Azure Service Principal Account ID (optional, browser auth is used if not specified)
        :param pulumi.Input[str] client_secret: Azure Service Principal Account password (optional, browser auth is used if not specified)
        :param pulumi.Input[str] custom_data: Path to file with custom-data
        :param pulumi.Input[str] disk_size: Disk size if using managed disk
        :param pulumi.Input[str] dns: A unique DNS label for the public IP adddress
        :param pulumi.Input[str] docker_port: Port number for Docker engine
        :param pulumi.Input[str] environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param pulumi.Input[str] fault_domain_count: Fault domain count to use for availability set
        :param pulumi.Input[str] image: Azure virtual machine OS image
        :param pulumi.Input[str] location: Azure region to create the virtual machine
        :param pulumi.Input[bool] managed_disks: Configures VM and availability set for managed disks
        :param pulumi.Input[bool] no_public_ip: Do not create a public IP address for the machine
        :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)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] open_ports: Make the specified port number accessible from the Internet
        :param pulumi.Input[bool] private_address_only: Only use a private IP address
        :param pulumi.Input[str] private_ip_address: Specify a static private IP address for the machine
        :param pulumi.Input[str] resource_group: Azure Resource Group name (will be created if missing)
        :param pulumi.Input[str] size: Size for Azure Virtual Machine
        :param pulumi.Input[str] ssh_user: Username for SSH login
        :param pulumi.Input[bool] static_public_ip: Assign a static public IP address to the machine
        :param pulumi.Input[str] storage_type: Type of Storage Account to host the OS Disk for the machine
        :param pulumi.Input[str] subnet: Azure Subnet Name to be used within the Virtual Network
        :param pulumi.Input[str] subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918
        :param pulumi.Input[str] subscription_id: Azure Subscription ID
        :param pulumi.Input[str] tags: Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        :param pulumi.Input[str] tenant_id: Azure Tenant ID
        :param pulumi.Input[str] update_domain_count: Update domain count to use for availability set
        :param pulumi.Input[bool] use_private_ip: Use private IP address of the machine to connect
        :param pulumi.Input[bool] use_public_ip_standard_sku: Use the standard SKU when creating a Public IP for the Azure VM instance
        :param pulumi.Input[str] vnet: Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        if accelerated_networking is not None:
            pulumi.set(__self__, "accelerated_networking", accelerated_networking)
        if availability_set is not None:
            pulumi.set(__self__, "availability_set", availability_set)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        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_address_only is not None:
            pulumi.set(__self__, "private_address_only", private_address_only)
        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 tags is not None:
            pulumi.set(__self__, "tags", tags)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_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 use_public_ip_standard_sku is not None:
            pulumi.set(__self__, "use_public_ip_standard_sku", use_public_ip_standard_sku)
        if vnet is not None:
            pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="acceleratedNetworking")
    def accelerated_networking(self) -> Optional[pulumi.Input[bool]]:
        """
        Use Accelerated Networking when creating a network interface for the Azure VM
        """
        return pulumi.get(self, "accelerated_networking")

    @accelerated_networking.setter
    def accelerated_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "accelerated_networking", value)

    @property
    @pulumi.getter(name="availabilitySet")
    def availability_set(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Availability Set to place the virtual machine into
        """
        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="availabilityZone")
    def availability_zone(self) -> Optional[pulumi.Input[str]]:
        """
        The Availability Zone that the Azure VM should be created in
        """
        return pulumi.get(self, "availability_zone")

    @availability_zone.setter
    def availability_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "availability_zone", value)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Service Principal Account ID (optional, browser auth is used if not specified)
        """
        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 (optional, browser auth is used if not specified)
        """
        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
        """
        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]]:
        """
        Disk size if using managed disk
        """
        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
        """
        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]]:
        """
        Port number for Docker engine
        """
        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)
        """
        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
        """
        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]]:
        """
        Azure virtual machine OS image
        """
        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
        """
        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
        """
        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
        """
        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)
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @open_ports.setter
    def open_ports(self, value: Optional[pulumi.Input[Sequence[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
        """
        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="privateIpAddress")
    def private_ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        Specify a static private IP address for the machine
        """
        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)
        """
        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]]:
        """
        Size for Azure Virtual Machine
        """
        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]]:
        """
        Username for SSH login
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
    def tags(self) -> Optional[pulumi.Input[str]]:
        """
        Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Tenant ID
        """
        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="updateDomainCount")
    def update_domain_count(self) -> Optional[pulumi.Input[str]]:
        """
        Update domain count to use for availability set
        """
        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
        """
        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(name="usePublicIpStandardSku")
    def use_public_ip_standard_sku(self) -> Optional[pulumi.Input[bool]]:
        """
        Use the standard SKU when creating a Public IP for the Azure VM instance
        """
        return pulumi.get(self, "use_public_ip_standard_sku")

    @use_public_ip_standard_sku.setter
    def use_public_ip_standard_sku(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_public_ip_standard_sku", value)

    @property
    @pulumi.getter
    def vnet(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        return pulumi.get(self, "vnet")

    @vnet.setter
    def vnet(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vnet", value)


@pulumi.input_type
class MachineConfigV2DigitaloceanConfigArgs:
    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_contents: Optional[pulumi.Input[str]] = None,
                 ssh_key_fingerprint: 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
        :param pulumi.Input[bool] backups: Enable backups for droplet
        :param pulumi.Input[str] image: Digital Ocean Image
        :param pulumi.Input[bool] ipv6: Enable ipv6 for droplet
        :param pulumi.Input[bool] monitoring: Enable monitoring for droplet
        :param pulumi.Input[bool] private_networking: Enable private networking for droplet
        :param pulumi.Input[str] region: Digital Ocean region
        :param pulumi.Input[str] size: Digital Ocean size
        :param pulumi.Input[str] ssh_key_contents: SSH private key contents
        :param pulumi.Input[str] ssh_key_fingerprint: SSH key fingerprint
        :param pulumi.Input[str] ssh_port: SSH port
        :param pulumi.Input[str] ssh_user: SSH username
        :param pulumi.Input[str] tags: Comma-separated list of tags to apply to the Droplet
        :param pulumi.Input[str] userdata: Path to file with cloud-init user-data
        """
        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_contents is not None:
            pulumi.set(__self__, "ssh_key_contents", ssh_key_contents)
        if ssh_key_fingerprint is not None:
            pulumi.set(__self__, "ssh_key_fingerprint", ssh_key_fingerprint)
        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
        """
        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
        """
        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]]:
        """
        Digital Ocean Image
        """
        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
        """
        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
        """
        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
        """
        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]]:
        """
        Digital Ocean region
        """
        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
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="sshKeyContents")
    def ssh_key_contents(self) -> Optional[pulumi.Input[str]]:
        """
        SSH private key contents
        """
        return pulumi.get(self, "ssh_key_contents")

    @ssh_key_contents.setter
    def ssh_key_contents(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssh_key_contents", value)

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[pulumi.Input[str]]:
        """
        SSH key fingerprint
        """
        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="sshPort")
    def ssh_port(self) -> Optional[pulumi.Input[str]]:
        """
        SSH port
        """
        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]]:
        """
        SSH username
        """
        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]]:
        """
        Comma-separated list of tags to apply to the Droplet
        """
        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
        """
        return pulumi.get(self, "userdata")

    @userdata.setter
    def userdata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "userdata", value)


@pulumi.input_type
class MachineConfigV2HarvesterConfigArgs:
    def __init__(__self__, *,
                 ssh_user: pulumi.Input[str],
                 vm_namespace: pulumi.Input[str],
                 cpu_count: Optional[pulumi.Input[str]] = None,
                 disk_bus: Optional[pulumi.Input[str]] = None,
                 disk_info: Optional[pulumi.Input[str]] = None,
                 disk_size: Optional[pulumi.Input[str]] = None,
                 image_name: Optional[pulumi.Input[str]] = None,
                 memory_size: Optional[pulumi.Input[str]] = None,
                 network_data: Optional[pulumi.Input[str]] = None,
                 network_info: Optional[pulumi.Input[str]] = None,
                 network_model: Optional[pulumi.Input[str]] = None,
                 network_name: Optional[pulumi.Input[str]] = None,
                 ssh_password: Optional[pulumi.Input[str]] = None,
                 user_data: Optional[pulumi.Input[str]] = None,
                 vm_affinity: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] ssh_user: SSH username
        :param pulumi.Input[str] vm_namespace: Virtual machine namespace
        :param pulumi.Input[str] cpu_count: CPU count
        :param pulumi.Input[str] disk_bus: Disk bus
        :param pulumi.Input[str] disk_info: A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        :param pulumi.Input[str] disk_size: Disk size (in GiB)
        :param pulumi.Input[str] image_name: Image name
        :param pulumi.Input[str] memory_size: Memory size (in GiB)
        :param pulumi.Input[str] network_data: NetworkData content of cloud-init, base64 is supported
        :param pulumi.Input[str] network_info: A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        :param pulumi.Input[str] network_model: Network model
        :param pulumi.Input[str] network_name: Network name
        :param pulumi.Input[str] ssh_password: SSH password
        :param pulumi.Input[str] user_data: UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        :param pulumi.Input[str] vm_affinity: VM affinity, base64 is supported
        """
        pulumi.set(__self__, "ssh_user", ssh_user)
        pulumi.set(__self__, "vm_namespace", vm_namespace)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if disk_bus is not None:
            warnings.warn("""Use disk_info instead""", DeprecationWarning)
            pulumi.log.warn("""disk_bus is deprecated: Use disk_info instead""")
        if disk_bus is not None:
            pulumi.set(__self__, "disk_bus", disk_bus)
        if disk_info is not None:
            pulumi.set(__self__, "disk_info", disk_info)
        if disk_size is not None:
            warnings.warn("""Use disk_info instead""", DeprecationWarning)
            pulumi.log.warn("""disk_size is deprecated: Use disk_info instead""")
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if image_name is not None:
            warnings.warn("""Use disk_info instead""", DeprecationWarning)
            pulumi.log.warn("""image_name is deprecated: Use disk_info instead""")
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if network_data is not None:
            pulumi.set(__self__, "network_data", network_data)
        if network_info is not None:
            pulumi.set(__self__, "network_info", network_info)
        if network_model is not None:
            warnings.warn("""Use network_info instead""", DeprecationWarning)
            pulumi.log.warn("""network_model is deprecated: Use network_info instead""")
        if network_model is not None:
            pulumi.set(__self__, "network_model", network_model)
        if network_name is not None:
            warnings.warn("""Use network_info instead""", DeprecationWarning)
            pulumi.log.warn("""network_name is deprecated: Use network_info instead""")
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if vm_affinity is not None:
            pulumi.set(__self__, "vm_affinity", vm_affinity)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> pulumi.Input[str]:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: pulumi.Input[str]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter(name="vmNamespace")
    def vm_namespace(self) -> pulumi.Input[str]:
        """
        Virtual machine namespace
        """
        return pulumi.get(self, "vm_namespace")

    @vm_namespace.setter
    def vm_namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "vm_namespace", value)

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[pulumi.Input[str]]:
        """
        CPU count
        """
        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="diskBus")
    def disk_bus(self) -> Optional[pulumi.Input[str]]:
        """
        Disk bus
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_bus is deprecated: Use disk_info instead""")

        return pulumi.get(self, "disk_bus")

    @disk_bus.setter
    def disk_bus(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_bus", value)

    @property
    @pulumi.getter(name="diskInfo")
    def disk_info(self) -> Optional[pulumi.Input[str]]:
        """
        A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        """
        return pulumi.get(self, "disk_info")

    @disk_info.setter
    def disk_info(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_info", value)

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[pulumi.Input[str]]:
        """
        Disk size (in GiB)
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_size is deprecated: Use disk_info instead""")

        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(name="imageName")
    def image_name(self) -> Optional[pulumi.Input[str]]:
        """
        Image name
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""image_name is deprecated: Use disk_info instead""")

        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="memorySize")
    def memory_size(self) -> Optional[pulumi.Input[str]]:
        """
        Memory size (in GiB)
        """
        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(name="networkData")
    def network_data(self) -> Optional[pulumi.Input[str]]:
        """
        NetworkData content of cloud-init, base64 is supported
        """
        return pulumi.get(self, "network_data")

    @network_data.setter
    def network_data(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_data", value)

    @property
    @pulumi.getter(name="networkInfo")
    def network_info(self) -> Optional[pulumi.Input[str]]:
        """
        A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        """
        return pulumi.get(self, "network_info")

    @network_info.setter
    def network_info(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_info", value)

    @property
    @pulumi.getter(name="networkModel")
    def network_model(self) -> Optional[pulumi.Input[str]]:
        """
        Network model
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_model is deprecated: Use network_info instead""")

        return pulumi.get(self, "network_model")

    @network_model.setter
    def network_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_model", value)

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[pulumi.Input[str]]:
        """
        Network name
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_name is deprecated: Use network_info instead""")

        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="sshPassword")
    def ssh_password(self) -> Optional[pulumi.Input[str]]:
        """
        SSH password
        """
        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="userData")
    def user_data(self) -> Optional[pulumi.Input[str]]:
        """
        UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        """
        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="vmAffinity")
    def vm_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        VM affinity, base64 is supported
        """
        return pulumi.get(self, "vm_affinity")

    @vm_affinity.setter
    def vm_affinity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vm_affinity", value)


@pulumi.input_type
class MachineConfigV2LinodeConfigArgs:
    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
        :param pulumi.Input[bool] create_private_ip: Create private IP for the instance
        :param pulumi.Input[str] docker_port: Docker Port
        :param pulumi.Input[str] image: Specifies the Linode Instance image which determines the OS distribution and base files
        :param pulumi.Input[str] instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        :param pulumi.Input[str] label: Linode Instance Label
        :param pulumi.Input[str] region: Specifies the region (location) of the Linode instance
        :param pulumi.Input[str] root_pass: Root Password
        :param pulumi.Input[str] ssh_port: Linode Instance SSH Port
        :param pulumi.Input[str] ssh_user: Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        :param pulumi.Input[str] stackscript: Specifies the Linode StackScript to use to create the instance
        :param pulumi.Input[str] stackscript_data: A JSON string specifying data for the selected StackScript
        :param pulumi.Input[str] swap_size: Linode Instance Swap Size (MB)
        :param pulumi.Input[str] tags: A comma separated list of tags to apply to the the Linode resource
        :param pulumi.Input[str] token: Linode API Token
        :param pulumi.Input[str] ua_prefix: Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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.
        """
        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
        """
        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]]:
        """
        Specifies the region (location) of the Linode instance
        """
        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
        """
        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]]:
        """
        Linode Instance SSH Port
        """
        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]]:
        """
        Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        """
        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
        """
        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
        """
        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)
        """
        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]]:
        """
        A comma separated list of tags to apply to the the Linode resource
        """
        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
        """
        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'
        """
        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 MachineConfigV2OpenstackConfigArgs:
    def __init__(__self__, *,
                 auth_url: pulumi.Input[str],
                 availability_zone: pulumi.Input[str],
                 region: pulumi.Input[str],
                 active_timeout: Optional[pulumi.Input[str]] = None,
                 application_credential_id: Optional[pulumi.Input[str]] = None,
                 application_credential_name: Optional[pulumi.Input[str]] = None,
                 application_credential_secret: Optional[pulumi.Input[str]] = None,
                 boot_from_volume: Optional[pulumi.Input[bool]] = 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_domain_id: Optional[pulumi.Input[str]] = None,
                 tenant_domain_name: 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,
                 user_domain_id: Optional[pulumi.Input[str]] = None,
                 user_domain_name: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None,
                 volume_device_path: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[str]] = None,
                 volume_name: Optional[pulumi.Input[str]] = None,
                 volume_size: Optional[pulumi.Input[str]] = None,
                 volume_type: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if application_credential_id is not None:
            pulumi.set(__self__, "application_credential_id", application_credential_id)
        if application_credential_name is not None:
            pulumi.set(__self__, "application_credential_name", application_credential_name)
        if application_credential_secret is not None:
            pulumi.set(__self__, "application_credential_secret", application_credential_secret)
        if boot_from_volume is not None:
            pulumi.set(__self__, "boot_from_volume", boot_from_volume)
        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_domain_id is not None:
            pulumi.set(__self__, "tenant_domain_id", tenant_domain_id)
        if tenant_domain_name is not None:
            pulumi.set(__self__, "tenant_domain_name", tenant_domain_name)
        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)
        if user_domain_id is not None:
            pulumi.set(__self__, "user_domain_id", user_domain_id)
        if user_domain_name is not None:
            pulumi.set(__self__, "user_domain_name", user_domain_name)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if volume_device_path is not None:
            pulumi.set(__self__, "volume_device_path", volume_device_path)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_name is not None:
            pulumi.set(__self__, "volume_name", volume_name)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @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(name="availabilityZone")
    def availability_zone(self) -> pulumi.Input[str]:
        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]:
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[str]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[pulumi.Input[str]]:
        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(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "application_credential_id")

    @application_credential_id.setter
    def application_credential_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_credential_id", value)

    @property
    @pulumi.getter(name="applicationCredentialName")
    def application_credential_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "application_credential_name")

    @application_credential_name.setter
    def application_credential_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_credential_name", value)

    @property
    @pulumi.getter(name="applicationCredentialSecret")
    def application_credential_secret(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "application_credential_secret")

    @application_credential_secret.setter
    def application_credential_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_credential_secret", value)

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "boot_from_volume")

    @boot_from_volume.setter
    def boot_from_volume(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "boot_from_volume", value)

    @property
    @pulumi.getter
    def cacert(self) -> Optional[pulumi.Input[str]]:
        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]]:
        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]]:
        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(name="endpointType")
    def endpoint_type(self) -> Optional[pulumi.Input[str]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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="tenantDomainId")
    def tenant_domain_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tenant_domain_id")

    @tenant_domain_id.setter
    def tenant_domain_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_domain_id", value)

    @property
    @pulumi.getter(name="tenantDomainName")
    def tenant_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tenant_domain_name")

    @tenant_domain_name.setter
    def tenant_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_domain_name", 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="userDataFile")
    def user_data_file(self) -> Optional[pulumi.Input[str]]:
        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)

    @property
    @pulumi.getter(name="userDomainId")
    def user_domain_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user_domain_id")

    @user_domain_id.setter
    def user_domain_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_domain_id", value)

    @property
    @pulumi.getter(name="userDomainName")
    def user_domain_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user_domain_name")

    @user_domain_name.setter
    def user_domain_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_domain_name", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="volumeDevicePath")
    def volume_device_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_device_path")

    @volume_device_path.setter
    def volume_device_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_device_path", value)

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_id")

    @volume_id.setter
    def volume_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_id", value)

    @property
    @pulumi.getter(name="volumeName")
    def volume_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_name")

    @volume_name.setter
    def volume_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_name", value)

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_size")

    @volume_size.setter
    def volume_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_size", value)

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[str]]:
        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 MachineConfigV2VsphereConfigArgs:
    def __init__(__self__, *,
                 boot2docker_url: Optional[pulumi.Input[str]] = None,
                 cfgparams: Optional[pulumi.Input[Sequence[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[Sequence[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,
                 graceful_shutdown_timeout: Optional[pulumi.Input[str]] = None,
                 hostsystem: Optional[pulumi.Input[str]] = None,
                 memory_size: Optional[pulumi.Input[str]] = None,
                 networks: Optional[pulumi.Input[Sequence[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[Sequence[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[Sequence[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 image
        :param pulumi.Input[Sequence[pulumi.Input[str]]] cfgparams: vSphere vm configuration parameters (used for guestinfo)
        :param pulumi.Input[str] clone_from: If you choose creation type clone a name of what you want to clone is required
        :param pulumi.Input[str] cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data
        :param pulumi.Input[str] cloudinit: vSphere cloud-init filepath or url to add to guestinfo
        :param pulumi.Input[str] content_library: If you choose to clone from a content library template specify the name of the library
        :param pulumi.Input[str] cpu_count: vSphere CPU number for docker VM
        :param pulumi.Input[str] creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_attributes: vSphere custom attributes, format key/value e.g. '200=my custom value'
        :param pulumi.Input[str] datacenter: vSphere datacenter for virtual machine
        :param pulumi.Input[str] datastore: vSphere datastore for virtual machine
        :param pulumi.Input[str] datastore_cluster: vSphere datastore cluster for virtual machine
        :param pulumi.Input[str] disk_size: vSphere size of disk for docker VM (in MB)
        :param pulumi.Input[str] folder: vSphere folder for the docker VM. This folder must already exist in the datacenter
        :param pulumi.Input[str] graceful_shutdown_timeout: Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        :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
        :param pulumi.Input[str] memory_size: vSphere size of memory for docker VM (in MB)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] networks: vSphere network where the virtual machine will be attached
        :param pulumi.Input[str] password: vSphere password
        :param pulumi.Input[str] pool: vSphere resource pool for docker VM
        :param pulumi.Input[str] ssh_password: If using a non-B2D image you can specify the ssh password
        :param pulumi.Input[str] ssh_port: If using a non-B2D image you can specify the ssh port
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user
        :param pulumi.Input[str] ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: vSphere tags id e.g. urn:xxx
        :param pulumi.Input[str] username: vSphere username
        :param pulumi.Input[str] vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        :param pulumi.Input[str] vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        :param pulumi.Input[Sequence[pulumi.Input[str]]] vapp_properties: vSphere vApp properties
        :param pulumi.Input[str] vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        :param pulumi.Input[str] vcenter: vSphere IP/hostname for vCenter
        :param pulumi.Input[str] vcenter_port: vSphere Port for vCenter
        """
        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 graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        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 image
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere vm configuration parameters (used for guestinfo)
        """
        return pulumi.get(self, "cfgparams")

    @cfgparams.setter
    def cfgparams(self, value: Optional[pulumi.Input[Sequence[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 clone a name of what you want to clone is required
        """
        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
        """
        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 filepath or url to add to guestinfo
        """
        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
        """
        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
        """
        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
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere custom attributes, format key/value e.g. '200=my custom value'
        """
        return pulumi.get(self, "custom_attributes")

    @custom_attributes.setter
    def custom_attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "custom_attributes", value)

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere datacenter for virtual machine
        """
        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 virtual machine
        """
        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
        """
        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)
        """
        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
        """
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        """
        return pulumi.get(self, "graceful_shutdown_timeout")

    @graceful_shutdown_timeout.setter
    def graceful_shutdown_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "graceful_shutdown_timeout", 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
        """
        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)
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere network where the virtual machine will be attached
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "networks", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere password
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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, defaults to staff e.g. docker:staff
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere tags id e.g. urn:xxx
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere username
        """
        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
        """
        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
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere vApp properties
        """
        return pulumi.get(self, "vapp_properties")

    @vapp_properties.setter
    def vapp_properties(self, value: Optional[pulumi.Input[Sequence[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
        """
        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
        """
        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
        """
        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 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
        :param pulumi.Input[str] project_id: Project ID for answer
        :param pulumi.Input[Mapping[str, Any]] values: Key/values for answer
        """
        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
        """
        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 answer
        """
        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
        """
        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: member, owner, read-only
        :param pulumi.Input[str] group_principal_id: Member group principal id
        :param pulumi.Input[str] user_principal_id: Member user principal id
        """
        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: member, owner, read-only
        """
        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
        """
        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
        """
        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
        :param pulumi.Input[str] app_id: App ID for target
        :param pulumi.Input[str] health_state: App health state for target
        :param pulumi.Input[str] state: App state for target
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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: Rolling update for upgrade strategy
        """
        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']]:
        """
        Rolling update for upgrade strategy
        """
        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[int]] = None,
                 interval: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] batch_size: Rolling update batch size
        :param pulumi.Input[int] interval: Rolling update interval
        """
        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[int]]:
        """
        Rolling update batch size
        """
        return pulumi.get(self, "batch_size")

    @batch_size.setter
    def batch_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "batch_size", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input[int]]:
        """
        Rolling update interval
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input[int]]):
        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):
        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]]:
        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]]:
        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]]:
        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]]:
        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']):
        pulumi.set(__self__, "limit", limit)

    @property
    @pulumi.getter
    def limit(self) -> pulumi.Input['NamespaceResourceQuotaLimitArgs']:
        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):
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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):
        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]:
        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]:
        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]]:
        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]]:
        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[Sequence[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,
                 http_endpoint: Optional[pulumi.Input[str]] = None,
                 http_tokens: 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,
                 kms_key: Optional[pulumi.Input[str]] = None,
                 monitoring: Optional[pulumi.Input[bool]] = None,
                 open_ports: Optional[pulumi.Input[Sequence[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
        :param pulumi.Input[str] region: AWS Region
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: AWS VPC security group
        :param pulumi.Input[str] subnet_id: AWS VPC subnet id
        :param pulumi.Input[str] vpc_id: AWS VPC id
        :param pulumi.Input[str] zone: AWS zone for instance (i.e. a,b,c,d,e)
        :param pulumi.Input[str] access_key: AWS Access Key
        :param pulumi.Input[str] block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        :param pulumi.Input[str] device_name: AWS root device name
        :param pulumi.Input[bool] encrypt_ebs_volume: Encrypt EBS volume
        :param pulumi.Input[str] endpoint: Optional endpoint URL (hostname only or fully qualified URI)
        :param pulumi.Input[str] http_endpoint: Enables or disables the HTTP metadata endpoint on your instances
        :param pulumi.Input[str] http_tokens: The state of token usage for your instance metadata requests
        :param pulumi.Input[str] iam_instance_profile: AWS IAM Instance Profile
        :param pulumi.Input[bool] insecure_transport: Disable SSL when sending requests
        :param pulumi.Input[str] instance_type: AWS instance type
        :param pulumi.Input[str] kms_key: Custom KMS key ID using the AWS Managed CMK
        :param pulumi.Input[bool] monitoring: Set this flag to enable CloudWatch monitoring
        :param pulumi.Input[Sequence[pulumi.Input[str]]] open_ports: Make the specified port number accessible from the Internet
        :param pulumi.Input[bool] private_address_only: Only use a private IP address
        :param pulumi.Input[bool] request_spot_instance: Set this flag to request spot instance
        :param pulumi.Input[str] retries: Set retry count for recoverable failures (use -1 to disable)
        :param pulumi.Input[str] root_size: AWS root disk size (in GB)
        :param pulumi.Input[str] secret_key: AWS Secret Key
        :param pulumi.Input[bool] security_group_readonly: Skip adding default rules to security groups
        :param pulumi.Input[str] session_token: AWS Session Token
        :param pulumi.Input[str] spot_price: AWS spot instance bid price (in dollar)
        :param pulumi.Input[str] ssh_keypath: SSH Key for Instance
        :param pulumi.Input[str] ssh_user: Set the name of the ssh user
        :param pulumi.Input[str] tags: AWS Tags (e.g. key1,value1,key2,value2)
        :param pulumi.Input[bool] use_ebs_optimized_instance: Create an EBS optimized instance
        :param pulumi.Input[bool] use_private_address: Force the usage of private IP address
        :param pulumi.Input[str] userdata: Path to file with cloud-init user data
        :param pulumi.Input[str] volume_type: Amazon EBS volume type
        """
        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 http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if http_tokens is not None:
            pulumi.set(__self__, "http_tokens", http_tokens)
        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 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
        """
        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]:
        """
        AWS Region
        """
        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[Sequence[pulumi.Input[str]]]:
        """
        AWS VPC security group
        """
        return pulumi.get(self, "security_groups")

    @security_groups.setter
    def security_groups(self, value: pulumi.Input[Sequence[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
        """
        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
        """
        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)
        """
        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
        """
        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)
        """
        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
        """
        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
        """
        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)
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="httpEndpoint")
    def http_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Enables or disables the HTTP metadata endpoint on your instances
        """
        return pulumi.get(self, "http_endpoint")

    @http_endpoint.setter
    def http_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_endpoint", value)

    @property
    @pulumi.getter(name="httpTokens")
    def http_tokens(self) -> Optional[pulumi.Input[str]]:
        """
        The state of token usage for your instance metadata requests
        """
        return pulumi.get(self, "http_tokens")

    @http_tokens.setter
    def http_tokens(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_tokens", value)

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
        """
        AWS IAM Instance Profile
        """
        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
        """
        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]]:
        """
        AWS instance type
        """
        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="kmsKey")
    def kms_key(self) -> Optional[pulumi.Input[str]]:
        """
        Custom KMS key ID using the AWS Managed CMK
        """
        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]]:
        """
        Set this flag to enable CloudWatch monitoring
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @open_ports.setter
    def open_ports(self, value: Optional[pulumi.Input[Sequence[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
        """
        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
        """
        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)
        """
        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)
        """
        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
        """
        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
        """
        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
        """
        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)
        """
        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
        """
        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]]:
        """
        Set the name of the ssh user
        """
        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]]:
        """
        AWS Tags (e.g. key1,value1,key2,value2)
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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__, *,
                 accelerated_networking: Optional[pulumi.Input[bool]] = None,
                 availability_set: Optional[pulumi.Input[str]] = None,
                 availability_zone: 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[Sequence[pulumi.Input[str]]]] = None,
                 plan: Optional[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,
                 tags: Optional[pulumi.Input[str]] = None,
                 update_domain_count: Optional[pulumi.Input[str]] = None,
                 use_private_ip: Optional[pulumi.Input[bool]] = None,
                 use_public_ip_standard_sku: Optional[pulumi.Input[bool]] = None,
                 vnet: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] accelerated_networking: Enable Accelerated Networking when creating an Azure Network Interface
        :param pulumi.Input[str] availability_set: Azure Availability Set to place the virtual machine into
        :param pulumi.Input[str] availability_zone: The Azure Availability Zone the VM should be created in
        :param pulumi.Input[str] client_id: Azure Service Principal Account ID (optional, browser auth is used if not specified)
        :param pulumi.Input[str] client_secret: Azure Service Principal Account password (optional, browser auth is used if not specified)
        :param pulumi.Input[str] custom_data: Path to file with custom-data
        :param pulumi.Input[str] disk_size: Disk size if using managed disk
        :param pulumi.Input[str] dns: A unique DNS label for the public IP adddress
        :param pulumi.Input[str] docker_port: Port number for Docker engine
        :param pulumi.Input[str] environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param pulumi.Input[str] fault_domain_count: Fault domain count to use for availability set
        :param pulumi.Input[str] image: Azure virtual machine OS image
        :param pulumi.Input[str] location: Azure region to create the virtual machine
        :param pulumi.Input[bool] managed_disks: Configures VM and availability set for managed disks
        :param pulumi.Input[bool] no_public_ip: Do not create a public IP address for the machine
        :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)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] open_ports: Make the specified port number accessible from the Internet
        :param pulumi.Input[str] plan: Purchase plan for Azure Virtual Machine (in <publisher>:<product>:<plan> format)
        :param pulumi.Input[str] private_ip_address: Specify a static private IP address for the machine
        :param pulumi.Input[str] resource_group: Azure Resource Group name (will be created if missing)
        :param pulumi.Input[str] size: Size for Azure Virtual Machine
        :param pulumi.Input[str] ssh_user: Username for SSH login
        :param pulumi.Input[bool] static_public_ip: Assign a static public IP address to the machine
        :param pulumi.Input[str] storage_type: Type of Storage Account to host the OS Disk for the machine
        :param pulumi.Input[str] subnet: Azure Subnet Name to be used within the Virtual Network
        :param pulumi.Input[str] subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918
        :param pulumi.Input[str] subscription_id: Azure Subscription ID
        :param pulumi.Input[str] tags: Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        :param pulumi.Input[str] update_domain_count: Update domain count to use for availability set
        :param pulumi.Input[bool] use_private_ip: Use private IP address of the machine to connect
        :param pulumi.Input[bool] use_public_ip_standard_sku: Use the Standard SKU when creating a public IP for an Azure VM
        :param pulumi.Input[str] vnet: Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        if accelerated_networking is not None:
            pulumi.set(__self__, "accelerated_networking", accelerated_networking)
        if availability_set is not None:
            pulumi.set(__self__, "availability_set", availability_set)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        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 plan is not None:
            pulumi.set(__self__, "plan", plan)
        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 tags is not None:
            pulumi.set(__self__, "tags", tags)
        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 use_public_ip_standard_sku is not None:
            pulumi.set(__self__, "use_public_ip_standard_sku", use_public_ip_standard_sku)
        if vnet is not None:
            pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="acceleratedNetworking")
    def accelerated_networking(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Accelerated Networking when creating an Azure Network Interface
        """
        return pulumi.get(self, "accelerated_networking")

    @accelerated_networking.setter
    def accelerated_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "accelerated_networking", value)

    @property
    @pulumi.getter(name="availabilitySet")
    def availability_set(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Availability Set to place the virtual machine into
        """
        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="availabilityZone")
    def availability_zone(self) -> Optional[pulumi.Input[str]]:
        """
        The Azure Availability Zone the VM should be created in
        """
        return pulumi.get(self, "availability_zone")

    @availability_zone.setter
    def availability_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "availability_zone", value)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Service Principal Account ID (optional, browser auth is used if not specified)
        """
        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 (optional, browser auth is used if not specified)
        """
        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
        """
        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]]:
        """
        Disk size if using managed disk
        """
        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
        """
        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]]:
        """
        Port number for Docker engine
        """
        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)
        """
        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
        """
        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]]:
        """
        Azure virtual machine OS image
        """
        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
        """
        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
        """
        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
        """
        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)
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @open_ports.setter
    def open_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "open_ports", value)

    @property
    @pulumi.getter
    def plan(self) -> Optional[pulumi.Input[str]]:
        """
        Purchase plan for Azure Virtual Machine (in <publisher>:<product>:<plan> format)
        """
        return pulumi.get(self, "plan")

    @plan.setter
    def plan(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "plan", value)

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        Specify a static private IP address for the machine
        """
        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)
        """
        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]]:
        """
        Size for Azure Virtual Machine
        """
        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]]:
        """
        Username for SSH login
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
    def tags(self) -> Optional[pulumi.Input[str]]:
        """
        Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter(name="updateDomainCount")
    def update_domain_count(self) -> Optional[pulumi.Input[str]]:
        """
        Update domain count to use for availability set
        """
        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
        """
        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(name="usePublicIpStandardSku")
    def use_public_ip_standard_sku(self) -> Optional[pulumi.Input[bool]]:
        """
        Use the Standard SKU when creating a public IP for an Azure VM
        """
        return pulumi.get(self, "use_public_ip_standard_sku")

    @use_public_ip_standard_sku.setter
    def use_public_ip_standard_sku(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_public_ip_standard_sku", value)

    @property
    @pulumi.getter
    def vnet(self) -> Optional[pulumi.Input[str]]:
        """
        Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        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
        :param pulumi.Input[bool] backups: Enable backups for droplet
        :param pulumi.Input[str] image: Digital Ocean Image
        :param pulumi.Input[bool] ipv6: Enable ipv6 for droplet
        :param pulumi.Input[bool] monitoring: Enable monitoring for droplet
        :param pulumi.Input[bool] private_networking: Enable private networking for droplet
        :param pulumi.Input[str] region: Digital Ocean region
        :param pulumi.Input[str] size: Digital Ocean size
        :param pulumi.Input[str] ssh_key_fingerprint: SSH key fingerprint
        :param pulumi.Input[str] ssh_key_path: SSH private key path
        :param pulumi.Input[str] ssh_port: SSH port
        :param pulumi.Input[str] ssh_user: SSH username
        :param pulumi.Input[str] tags: Comma-separated list of tags to apply to the Droplet
        :param pulumi.Input[str] userdata: Path to file with cloud-init user-data
        """
        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
        """
        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
        """
        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]]:
        """
        Digital Ocean Image
        """
        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
        """
        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
        """
        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
        """
        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]]:
        """
        Digital Ocean region
        """
        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
        """
        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
        """
        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
        """
        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]]:
        """
        SSH port
        """
        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]]:
        """
        SSH username
        """
        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]]:
        """
        Comma-separated list of tags to apply to the Droplet
        """
        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
        """
        return pulumi.get(self, "userdata")

    @userdata.setter
    def userdata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "userdata", value)


@pulumi.input_type
class NodeTemplateHarvesterConfigArgs:
    def __init__(__self__, *,
                 ssh_user: pulumi.Input[str],
                 vm_namespace: pulumi.Input[str],
                 cpu_count: Optional[pulumi.Input[str]] = None,
                 disk_bus: Optional[pulumi.Input[str]] = None,
                 disk_info: Optional[pulumi.Input[str]] = None,
                 disk_size: Optional[pulumi.Input[str]] = None,
                 image_name: Optional[pulumi.Input[str]] = None,
                 memory_size: Optional[pulumi.Input[str]] = None,
                 network_data: Optional[pulumi.Input[str]] = None,
                 network_info: Optional[pulumi.Input[str]] = None,
                 network_model: Optional[pulumi.Input[str]] = None,
                 network_name: Optional[pulumi.Input[str]] = None,
                 ssh_password: Optional[pulumi.Input[str]] = None,
                 user_data: Optional[pulumi.Input[str]] = None,
                 vm_affinity: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] ssh_user: SSH username
        :param pulumi.Input[str] vm_namespace: Virtual machine namespace
        :param pulumi.Input[str] cpu_count: CPU count
        :param pulumi.Input[str] disk_bus: Disk bus
        :param pulumi.Input[str] disk_info: A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        :param pulumi.Input[str] disk_size: Disk size (in GiB)
        :param pulumi.Input[str] image_name: Image name
        :param pulumi.Input[str] memory_size: Memory size (in GiB)
        :param pulumi.Input[str] network_data: NetworkData content of cloud-init, base64 is supported
        :param pulumi.Input[str] network_info: A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        :param pulumi.Input[str] network_model: Network model
        :param pulumi.Input[str] network_name: Network name
        :param pulumi.Input[str] ssh_password: SSH password
        :param pulumi.Input[str] user_data: UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        :param pulumi.Input[str] vm_affinity: VM affinity, base64 is supported
        """
        pulumi.set(__self__, "ssh_user", ssh_user)
        pulumi.set(__self__, "vm_namespace", vm_namespace)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if disk_bus is not None:
            warnings.warn("""Use disk_info instead""", DeprecationWarning)
            pulumi.log.warn("""disk_bus is deprecated: Use disk_info instead""")
        if disk_bus is not None:
            pulumi.set(__self__, "disk_bus", disk_bus)
        if disk_info is not None:
            pulumi.set(__self__, "disk_info", disk_info)
        if disk_size is not None:
            warnings.warn("""Use disk_info instead""", DeprecationWarning)
            pulumi.log.warn("""disk_size is deprecated: Use disk_info instead""")
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if image_name is not None:
            warnings.warn("""Use disk_info instead""", DeprecationWarning)
            pulumi.log.warn("""image_name is deprecated: Use disk_info instead""")
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if network_data is not None:
            pulumi.set(__self__, "network_data", network_data)
        if network_info is not None:
            pulumi.set(__self__, "network_info", network_info)
        if network_model is not None:
            warnings.warn("""Use network_info instead""", DeprecationWarning)
            pulumi.log.warn("""network_model is deprecated: Use network_info instead""")
        if network_model is not None:
            pulumi.set(__self__, "network_model", network_model)
        if network_name is not None:
            warnings.warn("""Use network_info instead""", DeprecationWarning)
            pulumi.log.warn("""network_name is deprecated: Use network_info instead""")
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if vm_affinity is not None:
            pulumi.set(__self__, "vm_affinity", vm_affinity)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> pulumi.Input[str]:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @ssh_user.setter
    def ssh_user(self, value: pulumi.Input[str]):
        pulumi.set(self, "ssh_user", value)

    @property
    @pulumi.getter(name="vmNamespace")
    def vm_namespace(self) -> pulumi.Input[str]:
        """
        Virtual machine namespace
        """
        return pulumi.get(self, "vm_namespace")

    @vm_namespace.setter
    def vm_namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "vm_namespace", value)

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[pulumi.Input[str]]:
        """
        CPU count
        """
        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="diskBus")
    def disk_bus(self) -> Optional[pulumi.Input[str]]:
        """
        Disk bus
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_bus is deprecated: Use disk_info instead""")

        return pulumi.get(self, "disk_bus")

    @disk_bus.setter
    def disk_bus(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_bus", value)

    @property
    @pulumi.getter(name="diskInfo")
    def disk_info(self) -> Optional[pulumi.Input[str]]:
        """
        A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        """
        return pulumi.get(self, "disk_info")

    @disk_info.setter
    def disk_info(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_info", value)

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[pulumi.Input[str]]:
        """
        Disk size (in GiB)
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_size is deprecated: Use disk_info instead""")

        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(name="imageName")
    def image_name(self) -> Optional[pulumi.Input[str]]:
        """
        Image name
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""image_name is deprecated: Use disk_info instead""")

        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="memorySize")
    def memory_size(self) -> Optional[pulumi.Input[str]]:
        """
        Memory size (in GiB)
        """
        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(name="networkData")
    def network_data(self) -> Optional[pulumi.Input[str]]:
        """
        NetworkData content of cloud-init, base64 is supported
        """
        return pulumi.get(self, "network_data")

    @network_data.setter
    def network_data(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_data", value)

    @property
    @pulumi.getter(name="networkInfo")
    def network_info(self) -> Optional[pulumi.Input[str]]:
        """
        A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        """
        return pulumi.get(self, "network_info")

    @network_info.setter
    def network_info(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_info", value)

    @property
    @pulumi.getter(name="networkModel")
    def network_model(self) -> Optional[pulumi.Input[str]]:
        """
        Network model
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_model is deprecated: Use network_info instead""")

        return pulumi.get(self, "network_model")

    @network_model.setter
    def network_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_model", value)

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[pulumi.Input[str]]:
        """
        Network name
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_name is deprecated: Use network_info instead""")

        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="sshPassword")
    def ssh_password(self) -> Optional[pulumi.Input[str]]:
        """
        SSH password
        """
        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="userData")
    def user_data(self) -> Optional[pulumi.Input[str]]:
        """
        UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        """
        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="vmAffinity")
    def vm_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        VM affinity, base64 is supported
        """
        return pulumi.get(self, "vm_affinity")

    @vm_affinity.setter
    def vm_affinity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vm_affinity", value)


@pulumi.input_type
class NodeTemplateHetznerConfigArgs:
    def __init__(__self__, *,
                 api_token: pulumi.Input[str],
                 image: Optional[pulumi.Input[str]] = None,
                 networks: Optional[pulumi.Input[str]] = None,
                 server_labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 server_location: Optional[pulumi.Input[str]] = None,
                 server_type: Optional[pulumi.Input[str]] = None,
                 use_private_network: Optional[pulumi.Input[bool]] = None,
                 userdata: Optional[pulumi.Input[str]] = None,
                 volumes: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] api_token: Hetzner Cloud project API token
        :param pulumi.Input[str] image: Hetzner Cloud server image
        :param pulumi.Input[str] networks: Comma-separated list of network IDs or names which should be attached to the server private network interface
        :param pulumi.Input[Mapping[str, Any]] server_labels: Map of the labels which will be assigned to the server
        :param pulumi.Input[str] server_location: Hetzner Cloud datacenter
        :param pulumi.Input[str] server_type: Hetzner Cloud server type
        :param pulumi.Input[bool] use_private_network: Use private network
        :param pulumi.Input[str] userdata: Path to file with cloud-init user-data
        :param pulumi.Input[str] volumes: Comma-separated list of volume IDs or names which should be attached to the server
        """
        pulumi.set(__self__, "api_token", api_token)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if server_labels is not None:
            pulumi.set(__self__, "server_labels", server_labels)
        if server_location is not None:
            pulumi.set(__self__, "server_location", server_location)
        if server_type is not None:
            pulumi.set(__self__, "server_type", server_type)
        if use_private_network is not None:
            pulumi.set(__self__, "use_private_network", use_private_network)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)

    @property
    @pulumi.getter(name="apiToken")
    def api_token(self) -> pulumi.Input[str]:
        """
        Hetzner Cloud project API token
        """
        return pulumi.get(self, "api_token")

    @api_token.setter
    def api_token(self, value: pulumi.Input[str]):
        pulumi.set(self, "api_token", value)

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        Hetzner Cloud server image
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image", value)

    @property
    @pulumi.getter
    def networks(self) -> Optional[pulumi.Input[str]]:
        """
        Comma-separated list of network IDs or names which should be attached to the server private network interface
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "networks", value)

    @property
    @pulumi.getter(name="serverLabels")
    def server_labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Map of the labels which will be assigned to the server
        """
        return pulumi.get(self, "server_labels")

    @server_labels.setter
    def server_labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
        pulumi.set(self, "server_labels", value)

    @property
    @pulumi.getter(name="serverLocation")
    def server_location(self) -> Optional[pulumi.Input[str]]:
        """
        Hetzner Cloud datacenter
        """
        return pulumi.get(self, "server_location")

    @server_location.setter
    def server_location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "server_location", value)

    @property
    @pulumi.getter(name="serverType")
    def server_type(self) -> Optional[pulumi.Input[str]]:
        """
        Hetzner Cloud server type
        """
        return pulumi.get(self, "server_type")

    @server_type.setter
    def server_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "server_type", value)

    @property
    @pulumi.getter(name="usePrivateNetwork")
    def use_private_network(self) -> Optional[pulumi.Input[bool]]:
        """
        Use private network
        """
        return pulumi.get(self, "use_private_network")

    @use_private_network.setter
    def use_private_network(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_private_network", value)

    @property
    @pulumi.getter
    def userdata(self) -> Optional[pulumi.Input[str]]:
        """
        Path to file with cloud-init user-data
        """
        return pulumi.get(self, "userdata")

    @userdata.setter
    def userdata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "userdata", value)

    @property
    @pulumi.getter
    def volumes(self) -> Optional[pulumi.Input[str]]:
        """
        Comma-separated list of volume IDs or names which should be attached to the server
        """
        return pulumi.get(self, "volumes")

    @volumes.setter
    def volumes(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volumes", 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
        :param pulumi.Input[bool] create_private_ip: Create private IP for the instance
        :param pulumi.Input[str] docker_port: Docker Port
        :param pulumi.Input[str] image: Specifies the Linode Instance image which determines the OS distribution and base files
        :param pulumi.Input[str] instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        :param pulumi.Input[str] label: Linode Instance Label
        :param pulumi.Input[str] region: Specifies the region (location) of the Linode instance
        :param pulumi.Input[str] root_pass: Root Password
        :param pulumi.Input[str] ssh_port: Linode Instance SSH Port
        :param pulumi.Input[str] ssh_user: Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        :param pulumi.Input[str] stackscript: Specifies the Linode StackScript to use to create the instance
        :param pulumi.Input[str] stackscript_data: A JSON string specifying data for the selected StackScript
        :param pulumi.Input[str] swap_size: Linode Instance Swap Size (MB)
        :param pulumi.Input[str] tags: A comma separated list of tags to apply to the the Linode resource
        :param pulumi.Input[str] token: Linode API Token
        :param pulumi.Input[str] ua_prefix: Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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.
        """
        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
        """
        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]]:
        """
        Specifies the region (location) of the Linode instance
        """
        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
        """
        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]]:
        """
        Linode Instance SSH Port
        """
        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]]:
        """
        Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        """
        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
        """
        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
        """
        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)
        """
        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]]:
        """
        A comma separated list of tags to apply to the the Linode resource
        """
        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
        """
        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'
        """
        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 NodeTemplateNodeTaintArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str],
                 effect: Optional[pulumi.Input[str]] = None,
                 time_added: Optional[pulumi.Input[str]] = None):
        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]:
        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]:
        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]]:
        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]]:
        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 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):
        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]:
        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(name="xmlRpcUrl")
    def xml_rpc_url(self) -> pulumi.Input[str]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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],
                 active_timeout: Optional[pulumi.Input[str]] = None,
                 application_credential_id: Optional[pulumi.Input[str]] = None,
                 application_credential_name: Optional[pulumi.Input[str]] = None,
                 application_credential_secret: Optional[pulumi.Input[str]] = None,
                 boot_from_volume: Optional[pulumi.Input[bool]] = 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,
                 username: Optional[pulumi.Input[str]] = None,
                 volume_device_path: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[str]] = None,
                 volume_name: Optional[pulumi.Input[str]] = None,
                 volume_size: Optional[pulumi.Input[str]] = None,
                 volume_type: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if application_credential_id is not None:
            pulumi.set(__self__, "application_credential_id", application_credential_id)
        if application_credential_name is not None:
            pulumi.set(__self__, "application_credential_name", application_credential_name)
        if application_credential_secret is not None:
            pulumi.set(__self__, "application_credential_secret", application_credential_secret)
        if boot_from_volume is not None:
            pulumi.set(__self__, "boot_from_volume", boot_from_volume)
        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)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if volume_device_path is not None:
            pulumi.set(__self__, "volume_device_path", volume_device_path)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_name is not None:
            pulumi.set(__self__, "volume_name", volume_name)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @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(name="availabilityZone")
    def availability_zone(self) -> pulumi.Input[str]:
        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]:
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[str]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[pulumi.Input[str]]:
        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(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "application_credential_id")

    @application_credential_id.setter
    def application_credential_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_credential_id", value)

    @property
    @pulumi.getter(name="applicationCredentialName")
    def application_credential_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "application_credential_name")

    @application_credential_name.setter
    def application_credential_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_credential_name", value)

    @property
    @pulumi.getter(name="applicationCredentialSecret")
    def application_credential_secret(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "application_credential_secret")

    @application_credential_secret.setter
    def application_credential_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_credential_secret", value)

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "boot_from_volume")

    @boot_from_volume.setter
    def boot_from_volume(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "boot_from_volume", value)

    @property
    @pulumi.getter
    def cacert(self) -> Optional[pulumi.Input[str]]:
        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]]:
        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]]:
        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(name="endpointType")
    def endpoint_type(self) -> Optional[pulumi.Input[str]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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="userDataFile")
    def user_data_file(self) -> Optional[pulumi.Input[str]]:
        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)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="volumeDevicePath")
    def volume_device_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_device_path")

    @volume_device_path.setter
    def volume_device_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_device_path", value)

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_id")

    @volume_id.setter
    def volume_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_id", value)

    @property
    @pulumi.getter(name="volumeName")
    def volume_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_name")

    @volume_name.setter
    def volume_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_name", value)

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "volume_size")

    @volume_size.setter
    def volume_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_size", value)

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[str]]:
        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 NodeTemplateOutscaleConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 secret_key: pulumi.Input[str],
                 extra_tags_alls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 extra_tags_instances: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 root_disk_iops: Optional[pulumi.Input[int]] = None,
                 root_disk_size: Optional[pulumi.Input[int]] = None,
                 root_disk_type: Optional[pulumi.Input[str]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 source_omi: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_key: Outscale Access Key
        :param pulumi.Input[str] secret_key: Outscale Secret Key
        :param pulumi.Input[Sequence[pulumi.Input[str]]] extra_tags_alls: Extra tags for all created resources (e.g. key1=value1,key2=value2)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] extra_tags_instances: Extra tags only for instances (e.g. key1=value1,key2=value2)
        :param pulumi.Input[str] instance_type: Outscale VM type
        :param pulumi.Input[str] region: Outscale Region
        :param pulumi.Input[int] root_disk_iops: Iops for io1 Root Disk. From 1 to 13000.
        :param pulumi.Input[int] root_disk_size: Size of the Root Disk (in GB). From 1 to 14901.
        :param pulumi.Input[str] root_disk_type: Type of the Root Disk. Possible values are :'standard', 'gp2' or 'io1'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: Ids of user defined Security Groups to add to the machine
        :param pulumi.Input[str] source_omi: Outscale Machine Image to use as bootstrap for the VM
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if extra_tags_alls is not None:
            pulumi.set(__self__, "extra_tags_alls", extra_tags_alls)
        if extra_tags_instances is not None:
            pulumi.set(__self__, "extra_tags_instances", extra_tags_instances)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if root_disk_iops is not None:
            pulumi.set(__self__, "root_disk_iops", root_disk_iops)
        if root_disk_size is not None:
            pulumi.set(__self__, "root_disk_size", root_disk_size)
        if root_disk_type is not None:
            pulumi.set(__self__, "root_disk_type", root_disk_type)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if source_omi is not None:
            pulumi.set(__self__, "source_omi", source_omi)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        Outscale Access Key
        """
        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]:
        """
        Outscale Secret Key
        """
        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(name="extraTagsAlls")
    def extra_tags_alls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Extra tags for all created resources (e.g. key1=value1,key2=value2)
        """
        return pulumi.get(self, "extra_tags_alls")

    @extra_tags_alls.setter
    def extra_tags_alls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_tags_alls", value)

    @property
    @pulumi.getter(name="extraTagsInstances")
    def extra_tags_instances(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Extra tags only for instances (e.g. key1=value1,key2=value2)
        """
        return pulumi.get(self, "extra_tags_instances")

    @extra_tags_instances.setter
    def extra_tags_instances(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "extra_tags_instances", value)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[str]]:
        """
        Outscale VM type
        """
        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 region(self) -> Optional[pulumi.Input[str]]:
        """
        Outscale Region
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="rootDiskIops")
    def root_disk_iops(self) -> Optional[pulumi.Input[int]]:
        """
        Iops for io1 Root Disk. From 1 to 13000.
        """
        return pulumi.get(self, "root_disk_iops")

    @root_disk_iops.setter
    def root_disk_iops(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "root_disk_iops", value)

    @property
    @pulumi.getter(name="rootDiskSize")
    def root_disk_size(self) -> Optional[pulumi.Input[int]]:
        """
        Size of the Root Disk (in GB). From 1 to 14901.
        """
        return pulumi.get(self, "root_disk_size")

    @root_disk_size.setter
    def root_disk_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "root_disk_size", value)

    @property
    @pulumi.getter(name="rootDiskType")
    def root_disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the Root Disk. Possible values are :'standard', 'gp2' or 'io1'.
        """
        return pulumi.get(self, "root_disk_type")

    @root_disk_type.setter
    def root_disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "root_disk_type", value)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Ids of user defined Security Groups to add to the machine
        """
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="sourceOmi")
    def source_omi(self) -> Optional[pulumi.Input[str]]:
        """
        Outscale Machine Image to use as bootstrap for the VM
        """
        return pulumi.get(self, "source_omi")

    @source_omi.setter
    def source_omi(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source_omi", value)


@pulumi.input_type
class NodeTemplateVsphereConfigArgs:
    def __init__(__self__, *,
                 boot2docker_url: Optional[pulumi.Input[str]] = None,
                 cfgparams: Optional[pulumi.Input[Sequence[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[Sequence[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,
                 graceful_shutdown_timeout: Optional[pulumi.Input[str]] = None,
                 hostsystem: Optional[pulumi.Input[str]] = None,
                 memory_size: Optional[pulumi.Input[str]] = None,
                 networks: Optional[pulumi.Input[Sequence[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[Sequence[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[Sequence[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 image
        :param pulumi.Input[Sequence[pulumi.Input[str]]] cfgparams: vSphere vm configuration parameters (used for guestinfo)
        :param pulumi.Input[str] clone_from: If you choose creation type clone a name of what you want to clone is required
        :param pulumi.Input[str] cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data
        :param pulumi.Input[str] cloudinit: vSphere cloud-init filepath or url to add to guestinfo
        :param pulumi.Input[str] content_library: If you choose to clone from a content library template specify the name of the library
        :param pulumi.Input[str] cpu_count: vSphere CPU number for docker VM
        :param pulumi.Input[str] creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_attributes: vSphere custom attributes, format key/value e.g. '200=my custom value'
        :param pulumi.Input[str] datacenter: vSphere datacenter for virtual machine
        :param pulumi.Input[str] datastore: vSphere datastore for virtual machine
        :param pulumi.Input[str] datastore_cluster: vSphere datastore cluster for virtual machine
        :param pulumi.Input[str] disk_size: vSphere size of disk for docker VM (in MB)
        :param pulumi.Input[str] folder: vSphere folder for the docker VM. This folder must already exist in the datacenter
        :param pulumi.Input[str] graceful_shutdown_timeout: Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        :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
        :param pulumi.Input[str] memory_size: vSphere size of memory for docker VM (in MB)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] networks: vSphere network where the virtual machine will be attached
        :param pulumi.Input[str] password: vSphere password
        :param pulumi.Input[str] pool: vSphere resource pool for docker VM
        :param pulumi.Input[str] ssh_password: If using a non-B2D image you can specify the ssh password
        :param pulumi.Input[str] ssh_port: If using a non-B2D image you can specify the ssh port
        :param pulumi.Input[str] ssh_user: If using a non-B2D image you can specify the ssh user
        :param pulumi.Input[str] ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: vSphere tags id e.g. urn:xxx
        :param pulumi.Input[str] username: vSphere username
        :param pulumi.Input[str] vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        :param pulumi.Input[str] vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        :param pulumi.Input[Sequence[pulumi.Input[str]]] vapp_properties: vSphere vApp properties
        :param pulumi.Input[str] vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        :param pulumi.Input[str] vcenter: vSphere IP/hostname for vCenter
        :param pulumi.Input[str] vcenter_port: vSphere Port for vCenter
        """
        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 graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        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 image
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere vm configuration parameters (used for guestinfo)
        """
        return pulumi.get(self, "cfgparams")

    @cfgparams.setter
    def cfgparams(self, value: Optional[pulumi.Input[Sequence[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 clone a name of what you want to clone is required
        """
        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
        """
        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 filepath or url to add to guestinfo
        """
        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
        """
        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
        """
        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
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere custom attributes, format key/value e.g. '200=my custom value'
        """
        return pulumi.get(self, "custom_attributes")

    @custom_attributes.setter
    def custom_attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "custom_attributes", value)

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere datacenter for virtual machine
        """
        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 virtual machine
        """
        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
        """
        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)
        """
        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
        """
        return pulumi.get(self, "folder")

    @folder.setter
    def folder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "folder", value)

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        """
        return pulumi.get(self, "graceful_shutdown_timeout")

    @graceful_shutdown_timeout.setter
    def graceful_shutdown_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "graceful_shutdown_timeout", 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
        """
        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)
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere network where the virtual machine will be attached
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "networks", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere password
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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, defaults to staff e.g. docker:staff
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere tags id e.g. urn:xxx
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        vSphere username
        """
        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
        """
        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
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        vSphere vApp properties
        """
        return pulumi.get(self, "vapp_properties")

    @vapp_properties.setter
    def vapp_properties(self, value: Optional[pulumi.Input[Sequence[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
        """
        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
        """
        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
        """
        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 NotifierDingtalkConfigArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 proxy_url: Optional[pulumi.Input[str]] = None,
                 secret: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] url: Webhook URL
        :param pulumi.Input[str] proxy_url: Dingtalk proxy URL
        :param pulumi.Input[str] secret: Required for webhook with sign enabled
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Webhook URL
        """
        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]]:
        """
        Dingtalk proxy URL
        """
        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
    def secret(self) -> Optional[pulumi.Input[str]]:
        """
        Required for webhook with sign enabled
        """
        return pulumi.get(self, "secret")

    @secret.setter
    def secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret", value)


@pulumi.input_type
class NotifierMsteamsConfigArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 proxy_url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] url: Webhook URL
        :param pulumi.Input[str] proxy_url: MS teams proxy URL
        """
        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
        """
        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]]:
        """
        MS teams proxy URL
        """
        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 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
        :param pulumi.Input[str] proxy_url: Pagerduty proxy URL
        """
        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
        """
        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]]:
        """
        Pagerduty proxy URL
        """
        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: Slack default channel
        :param pulumi.Input[str] url: Slack URL
        :param pulumi.Input[str] proxy_url: Slack proxy URL
        """
        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]:
        """
        Slack default channel
        """
        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]:
        """
        Slack URL
        """
        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]]:
        """
        Slack proxy URL
        """
        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[int],
                 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: SMTP default recipient (string)
        :param pulumi.Input[str] host: SMTP host (string)
        :param pulumi.Input[int] 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]:
        """
        SMTP 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[int]:
        """
        SMTP port (int)
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[int]):
        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: Webhook 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]]:
        """
        Webhook 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 application agent ID
        :param pulumi.Input[str] corp: Wechat corporation ID
        :param pulumi.Input[str] default_recipient: Wechat default channel
        :param pulumi.Input[str] secret: Wechat application secret
        :param pulumi.Input[str] proxy_url: Wechat proxy URL
        :param pulumi.Input[str] recipient_type: Wechat recipient type
        """
        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 application agent ID
        """
        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
        """
        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 channel
        """
        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 application secret
        """
        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
        """
        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
        """
        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 PodSecurityAdmissionConfigurationTemplateDefaultsArgs:
    def __init__(__self__, *,
                 audit: Optional[pulumi.Input[str]] = None,
                 audit_version: Optional[pulumi.Input[str]] = None,
                 enforce: Optional[pulumi.Input[str]] = None,
                 enforce_version: Optional[pulumi.Input[str]] = None,
                 warn: Optional[pulumi.Input[str]] = None,
                 warn_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] audit: Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param pulumi.Input[str] audit_version: Pod Security Admission Configuration audit version (default: latest)
        :param pulumi.Input[str] enforce: Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param pulumi.Input[str] enforce_version: Pod Security Admission Configuration enforce version (default: latest)
        :param pulumi.Input[str] warn: Pod Security Admission Configuration warn. This warns the user about a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param pulumi.Input[str] warn_version: Pod Security Admission Configuration warn version (default: latest)
        """
        if audit is not None:
            pulumi.set(__self__, "audit", audit)
        if audit_version is not None:
            pulumi.set(__self__, "audit_version", audit_version)
        if enforce is not None:
            pulumi.set(__self__, "enforce", enforce)
        if enforce_version is not None:
            pulumi.set(__self__, "enforce_version", enforce_version)
        if warn is not None:
            pulumi.set(__self__, "warn", warn)
        if warn_version is not None:
            pulumi.set(__self__, "warn_version", warn_version)

    @property
    @pulumi.getter
    def audit(self) -> Optional[pulumi.Input[str]]:
        """
        Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "audit")

    @audit.setter
    def audit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audit", value)

    @property
    @pulumi.getter(name="auditVersion")
    def audit_version(self) -> Optional[pulumi.Input[str]]:
        """
        Pod Security Admission Configuration audit version (default: latest)
        """
        return pulumi.get(self, "audit_version")

    @audit_version.setter
    def audit_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audit_version", value)

    @property
    @pulumi.getter
    def enforce(self) -> Optional[pulumi.Input[str]]:
        """
        Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "enforce")

    @enforce.setter
    def enforce(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "enforce", value)

    @property
    @pulumi.getter(name="enforceVersion")
    def enforce_version(self) -> Optional[pulumi.Input[str]]:
        """
        Pod Security Admission Configuration enforce version (default: latest)
        """
        return pulumi.get(self, "enforce_version")

    @enforce_version.setter
    def enforce_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "enforce_version", value)

    @property
    @pulumi.getter
    def warn(self) -> Optional[pulumi.Input[str]]:
        """
        Pod Security Admission Configuration warn. This warns the user about a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "warn")

    @warn.setter
    def warn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "warn", value)

    @property
    @pulumi.getter(name="warnVersion")
    def warn_version(self) -> Optional[pulumi.Input[str]]:
        """
        Pod Security Admission Configuration warn version (default: latest)
        """
        return pulumi.get(self, "warn_version")

    @warn_version.setter
    def warn_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "warn_version", value)


@pulumi.input_type
class PodSecurityAdmissionConfigurationTemplateExemptionsArgs:
    def __init__(__self__, *,
                 namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 runtime_classes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 usernames: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: Pod Security Admission Configuration namespace exemptions
        :param pulumi.Input[Sequence[pulumi.Input[str]]] runtime_classes: Pod Security Admission Configuration runtime class exemptions
        :param pulumi.Input[Sequence[pulumi.Input[str]]] usernames: Pod Security Admission Configuration username exemptions
        """
        if namespaces is not None:
            pulumi.set(__self__, "namespaces", namespaces)
        if runtime_classes is not None:
            pulumi.set(__self__, "runtime_classes", runtime_classes)
        if usernames is not None:
            pulumi.set(__self__, "usernames", usernames)

    @property
    @pulumi.getter
    def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Pod Security Admission Configuration namespace exemptions
        """
        return pulumi.get(self, "namespaces")

    @namespaces.setter
    def namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "namespaces", value)

    @property
    @pulumi.getter(name="runtimeClasses")
    def runtime_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Pod Security Admission Configuration runtime class exemptions
        """
        return pulumi.get(self, "runtime_classes")

    @runtime_classes.setter
    def runtime_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "runtime_classes", value)

    @property
    @pulumi.getter
    def usernames(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Pod Security Admission Configuration username exemptions
        """
        return pulumi.get(self, "usernames")

    @usernames.setter
    def usernames(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "usernames", 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]):
        """
        :param pulumi.Input[str] driver: driver is the name of the Flexvolume driver.
        """
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> pulumi.Input[str]:
        """
        driver is the name of the Flexvolume driver.
        """
        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: pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        :param pulumi.Input[bool] read_only: when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        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]:
        """
        pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        """
        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]]:
        """
        when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        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[Sequence[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]]] = None,
                 rule: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]] ranges: ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        :param pulumi.Input[str] rule: rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        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[Sequence[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]]]:
        """
        ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateFsGroupRangeArgs']]]]):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[pulumi.Input[str]]:
        """
        rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        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[int],
                 min: pulumi.Input[int]):
        """
        :param pulumi.Input[int] max: max is the end of the range, inclusive.
        :param pulumi.Input[int] min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[int]:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[int]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[int]:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[int]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateHostPortArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[int],
                 min: pulumi.Input[int]):
        """
        :param pulumi.Input[int] max: max is the end of the range, inclusive.
        :param pulumi.Input[int] min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[int]:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[int]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[int]:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[int]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsGroupArgs:
    def __init__(__self__, *,
                 rule: pulumi.Input[str],
                 ranges: Optional[pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]]] = None):
        """
        :param pulumi.Input[str] rule: rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        :param pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]] ranges: ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> pulumi.Input[str]:
        """
        rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        """
        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[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]]]:
        """
        ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsGroupRangeArgs']]]]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsGroupRangeArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[int],
                 min: pulumi.Input[int]):
        """
        :param pulumi.Input[int] max: max is the end of the range, inclusive.
        :param pulumi.Input[int] min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[int]:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[int]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[int]:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[int]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsUserArgs:
    def __init__(__self__, *,
                 rule: pulumi.Input[str],
                 ranges: Optional[pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]]] = None):
        """
        :param pulumi.Input[str] rule: rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        :param pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]] ranges: ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> pulumi.Input[str]:
        """
        rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        """
        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[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]]]:
        """
        ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateRunAsUserRangeArgs']]]]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRunAsUserRangeArgs:
    def __init__(__self__, *,
                 max: pulumi.Input[int],
                 min: pulumi.Input[int]):
        """
        :param pulumi.Input[int] max: max is the end of the range, inclusive.
        :param pulumi.Input[int] min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[int]:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[int]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[int]:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[int]):
        pulumi.set(self, "min", value)


@pulumi.input_type
class PodSecurityPolicyTemplateRuntimeClassArgs:
    def __init__(__self__, *,
                 allowed_runtime_class_names: pulumi.Input[Sequence[pulumi.Input[str]]],
                 default_runtime_class_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_runtime_class_names: allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        :param pulumi.Input[str] default_runtime_class_name: defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        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[Sequence[pulumi.Input[str]]]:
        """
        allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        """
        return pulumi.get(self, "allowed_runtime_class_names")

    @allowed_runtime_class_names.setter
    def allowed_runtime_class_names(self, value: pulumi.Input[Sequence[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]]:
        """
        defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        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: rule is the strategy that will dictate the allowable labels that may be set.
        :param pulumi.Input['PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs'] se_linux_option: seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        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]:
        """
        rule is the strategy that will dictate the allowable labels that may be set.
        """
        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']]:
        """
        seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        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: Level is SELinux level label that applies to the container.
        :param pulumi.Input[str] role: Role is a SELinux role label that applies to the container.
        :param pulumi.Input[str] type: Type is a SELinux type label that applies to the container.
        :param pulumi.Input[str] user: User is a SELinux user label that applies to the container.
        """
        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]]:
        """
        Level is SELinux level label that applies to the container.
        """
        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]]:
        """
        Role is a SELinux role label that applies to the container.
        """
        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]]:
        """
        Type is a SELinux type label that applies to the container.
        """
        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]]:
        """
        User is a SELinux user label that applies to the container.
        """
        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[Sequence[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]]] = None,
                 rule: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]] ranges: ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        :param pulumi.Input[str] rule: rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        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[Sequence[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]]]:
        """
        ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PodSecurityPolicyTemplateSupplementalGroupRangeArgs']]]]):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[pulumi.Input[str]]:
        """
        rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        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[int],
                 min: pulumi.Input[int]):
        """
        :param pulumi.Input[int] max: max is the end of the range, inclusive.
        :param pulumi.Input[int] min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> pulumi.Input[int]:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: pulumi.Input[int]):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> pulumi.Input[int]:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: pulumi.Input[int]):
        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
        :param pulumi.Input[bool] default_recipient: Use notifier default recipient
        :param pulumi.Input[str] notifier_type: Recipient notifier type
        :param pulumi.Input[str] recipient: Recipient
        """
        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
        """
        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
        """
        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 type
        """
        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
        """
        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
        :param pulumi.Input[str] expression: Metric rule expression
        :param pulumi.Input[float] threshold_value: Metric rule threshold value
        :param pulumi.Input[str] comparison: Metric rule comparison
        :param pulumi.Input[str] description: Metric rule description
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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
        """
        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[int]] = None,
                 restart_times: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] pod_id: Pod ID
        :param pulumi.Input[str] condition: Pod rule condition
        :param pulumi.Input[int] restart_interval_seconds: Pod rule restart interval seconds
        :param pulumi.Input[int] restart_times: Pod rule restart times
        """
        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
        """
        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
        """
        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[int]]:
        """
        Pod rule restart interval seconds
        """
        return pulumi.get(self, "restart_interval_seconds")

    @restart_interval_seconds.setter
    def restart_interval_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_interval_seconds", value)

    @property
    @pulumi.getter(name="restartTimes")
    def restart_times(self) -> Optional[pulumi.Input[int]]:
        """
        Pod rule restart times
        """
        return pulumi.get(self, "restart_times")

    @restart_times.setter
    def restart_times(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_times", value)


@pulumi.input_type
class ProjectAlertRuleWorkloadRuleArgs:
    def __init__(__self__, *,
                 available_percentage: Optional[pulumi.Input[int]] = None,
                 selector: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 workload_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] available_percentage: Workload rule available percentage
        :param pulumi.Input[Mapping[str, Any]] selector: Workload rule selector
        :param pulumi.Input[str] workload_id: Workload ID
        """
        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[int]]:
        """
        Workload rule available percentage
        """
        return pulumi.get(self, "available_percentage")

    @available_percentage.setter
    def available_percentage(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "available_percentage", value)

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Workload rule selector
        """
        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
        """
        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):
        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]]:
        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]]:
        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]]:
        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]]:
        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 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: Answers for monitor input
        :param pulumi.Input[str] version: Monitoring version
        """
        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]]]:
        """
        Answers for monitor input
        """
        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]]:
        """
        Monitoring version
        """
        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']):
        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']:
        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']:
        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):
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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):
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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]]:
        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):
        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]:
        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]]:
        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]]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class RoleTemplateRuleArgs:
    def __init__(__self__, *,
                 api_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 non_resource_urls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resource_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resources: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 verbs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] api_groups: Policy rule api groups
        :param pulumi.Input[Sequence[pulumi.Input[str]]] non_resource_urls: Policy rule non resource urls
        :param pulumi.Input[Sequence[pulumi.Input[str]]] resource_names: Policy rule resource names
        :param pulumi.Input[Sequence[pulumi.Input[str]]] resources: Policy rule resources
        :param pulumi.Input[Sequence[pulumi.Input[str]]] verbs: Policy rule verbs
        """
        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[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @api_groups.setter
    def api_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "api_groups", value)

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @non_resource_urls.setter
    def non_resource_urls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "non_resource_urls", value)

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @resource_names.setter
    def resource_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "resource_names", value)

    @property
    @pulumi.getter
    def resources(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @resources.setter
    def resources(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "resources", value)

    @property
    @pulumi.getter
    def verbs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")

    @verbs.setter
    def verbs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "verbs", value)


@pulumi.input_type
class GetNotifierDingtalkConfigArgs:
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None,
                 secret: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: Dingtalk proxy URL
        :param str secret: Required for webhook with sign enabled
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: str):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Dingtalk proxy URL
        """
        return pulumi.get(self, "proxy_url")

    @proxy_url.setter
    def proxy_url(self, value: Optional[str]):
        pulumi.set(self, "proxy_url", value)

    @property
    @pulumi.getter
    def secret(self) -> Optional[str]:
        """
        Required for webhook with sign enabled
        """
        return pulumi.get(self, "secret")

    @secret.setter
    def secret(self, value: Optional[str]):
        pulumi.set(self, "secret", value)


@pulumi.input_type
class GetNotifierMsteamsConfigArgs:
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: MS teams proxy URL
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: str):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        MS teams proxy URL
        """
        return pulumi.get(self, "proxy_url")

    @proxy_url.setter
    def proxy_url(self, value: Optional[str]):
        pulumi.set(self, "proxy_url", 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):
        """
        :param str driver: driver is the name of the Flexvolume driver.
        """
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> str:
        """
        driver is the name of the Flexvolume driver.
        """
        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):
        """
        :param str path_prefix: pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        :param bool read_only: when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        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:
        """
        pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        """
        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]:
        """
        when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        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: Sequence['GetPodSecurityPolicyTemplateFsGroupRangeArgs'],
                 rule: Optional[str] = None):
        """
        :param Sequence['GetPodSecurityPolicyTemplateFsGroupRangeArgs'] ranges: ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        :param str rule: rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['GetPodSecurityPolicyTemplateFsGroupRangeArgs']:
        """
        ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Sequence['GetPodSecurityPolicyTemplateFsGroupRangeArgs']):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        """
        rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        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: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: int):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: int):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateHostPortArgs:
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: int):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: int):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsGroupArgs:
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs']] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        :param Sequence['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs'] ranges: ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: str):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs']]:
        """
        ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[Sequence['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs']]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsGroupRangeArgs:
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: int):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: int):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsUserArgs:
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['GetPodSecurityPolicyTemplateRunAsUserRangeArgs']] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        :param Sequence['GetPodSecurityPolicyTemplateRunAsUserRangeArgs'] ranges: ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        """
        return pulumi.get(self, "rule")

    @rule.setter
    def rule(self, value: str):
        pulumi.set(self, "rule", value)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['GetPodSecurityPolicyTemplateRunAsUserRangeArgs']]:
        """
        ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Optional[Sequence['GetPodSecurityPolicyTemplateRunAsUserRangeArgs']]):
        pulumi.set(self, "ranges", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRunAsUserRangeArgs:
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: int):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: int):
        pulumi.set(self, "min", value)


@pulumi.input_type
class GetPodSecurityPolicyTemplateRuntimeClassArgs:
    def __init__(__self__, *,
                 allowed_runtime_class_names: Sequence[str],
                 default_runtime_class_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_runtime_class_names: allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        :param str default_runtime_class_name: defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        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) -> Sequence[str]:
        """
        allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        """
        return pulumi.get(self, "allowed_runtime_class_names")

    @allowed_runtime_class_names.setter
    def allowed_runtime_class_names(self, value: Sequence[str]):
        pulumi.set(self, "allowed_runtime_class_names", value)

    @property
    @pulumi.getter(name="defaultRuntimeClassName")
    def default_runtime_class_name(self) -> Optional[str]:
        """
        defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        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):
        """
        :param str rule: rule is the strategy that will dictate the allowable labels that may be set.
        :param 'GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs' se_linux_option: seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        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:
        """
        rule is the strategy that will dictate the allowable labels that may be set.
        """
        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']:
        """
        seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        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):
        """
        :param str level: Level is SELinux level label that applies to the container.
        :param str role: Role is a SELinux role label that applies to the container.
        :param str type: Type is a SELinux type label that applies to the container.
        :param str user: User is a SELinux user label that applies to the container.
        """
        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]:
        """
        Level is SELinux level label that applies to the container.
        """
        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]:
        """
        Role is a SELinux role label that applies to the container.
        """
        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]:
        """
        Type is a SELinux type label that applies to the container.
        """
        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]:
        """
        User is a SELinux user label that applies to the container.
        """
        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: Sequence['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs'],
                 rule: Optional[str] = None):
        """
        :param Sequence['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs'] ranges: ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        :param str rule: rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs']:
        """
        ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @ranges.setter
    def ranges(self, value: Sequence['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs']):
        pulumi.set(self, "ranges", value)

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        """
        rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        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: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @max.setter
    def max(self, value: int):
        pulumi.set(self, "max", value)

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")

    @min.setter
    def min(self, value: int):
        pulumi.set(self, "min", value)


