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

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

__all__ = [
    'CloudCredentialAmazonec2CredentialConfig',
    'CloudCredentialAzureCredentialConfig',
    'CloudCredentialDigitaloceanCredentialConfig',
    'CloudCredentialLinodeCredentialConfig',
    'CloudCredentialOpenstackCredentialConfig',
    'CloudCredentialVsphereCredentialConfig',
    'ClusterAksConfig',
    'ClusterAlertGroupRecipient',
    'ClusterAlertRuleEventRule',
    'ClusterAlertRuleMetricRule',
    'ClusterAlertRuleNodeRule',
    'ClusterAlertRuleSystemServiceRule',
    'ClusterAlterGroupRecipient',
    'ClusterAlterRuleEventRule',
    'ClusterAlterRuleMetricRule',
    'ClusterAlterRuleNodeRule',
    'ClusterAlterRuleSystemServiceRule',
    'ClusterClusterAuthEndpoint',
    'ClusterClusterMonitoringInput',
    'ClusterClusterRegistrationToken',
    'ClusterClusterTemplateAnswers',
    'ClusterClusterTemplateQuestion',
    'ClusterEksConfig',
    'ClusterGkeConfig',
    'ClusterK3sConfig',
    'ClusterK3sConfigUpgradeStrategy',
    'ClusterLoggingCustomTargetConfig',
    'ClusterLoggingElasticsearchConfig',
    'ClusterLoggingFluentdConfig',
    'ClusterLoggingFluentdConfigFluentServer',
    'ClusterLoggingKafkaConfig',
    'ClusterLoggingSplunkConfig',
    'ClusterLoggingSyslogConfig',
    'ClusterRkeConfig',
    'ClusterRkeConfigAuthentication',
    'ClusterRkeConfigAuthorization',
    'ClusterRkeConfigBastionHost',
    'ClusterRkeConfigCloudProvider',
    'ClusterRkeConfigCloudProviderAwsCloudProvider',
    'ClusterRkeConfigCloudProviderAwsCloudProviderGlobal',
    'ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride',
    'ClusterRkeConfigCloudProviderAzureCloudProvider',
    'ClusterRkeConfigCloudProviderOpenstackCloudProvider',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute',
    'ClusterRkeConfigCloudProviderVsphereCloudProvider',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderDisk',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace',
    'ClusterRkeConfigDns',
    'ClusterRkeConfigDnsNodelocal',
    'ClusterRkeConfigIngress',
    'ClusterRkeConfigMonitoring',
    'ClusterRkeConfigMonitoringUpdateStrategy',
    'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate',
    'ClusterRkeConfigNetwork',
    'ClusterRkeConfigNetworkCalicoNetworkProvider',
    'ClusterRkeConfigNetworkCanalNetworkProvider',
    'ClusterRkeConfigNetworkFlannelNetworkProvider',
    'ClusterRkeConfigNetworkWeaveNetworkProvider',
    'ClusterRkeConfigNode',
    'ClusterRkeConfigPrivateRegistry',
    'ClusterRkeConfigServices',
    'ClusterRkeConfigServicesEtcd',
    'ClusterRkeConfigServicesEtcdBackupConfig',
    'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig',
    'ClusterRkeConfigServicesKubeApi',
    'ClusterRkeConfigServicesKubeApiAuditLog',
    'ClusterRkeConfigServicesKubeApiAuditLogConfiguration',
    'ClusterRkeConfigServicesKubeApiEventRateLimit',
    'ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig',
    'ClusterRkeConfigServicesKubeController',
    'ClusterRkeConfigServicesKubelet',
    'ClusterRkeConfigServicesKubeproxy',
    'ClusterRkeConfigServicesScheduler',
    'ClusterRkeConfigUpgradeStrategy',
    'ClusterRkeConfigUpgradeStrategyDrainInput',
    'ClusterScheduledClusterScan',
    'ClusterScheduledClusterScanScanConfig',
    'ClusterScheduledClusterScanScanConfigCisScanConfig',
    'ClusterScheduledClusterScanScheduleConfig',
    'ClusterTemplateMember',
    'ClusterTemplateTemplateRevision',
    'ClusterTemplateTemplateRevisionClusterConfig',
    'ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthentication',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorization',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig',
    'ClusterTemplateTemplateRevisionQuestion',
    'EtcdBackupBackupConfig',
    'EtcdBackupBackupConfigS3BackupConfig',
    'MultiClusterAppAnswer',
    'MultiClusterAppMember',
    'MultiClusterAppTarget',
    'MultiClusterAppUpgradeStrategy',
    'MultiClusterAppUpgradeStrategyRollingUpdate',
    'NamespaceContainerResourceLimit',
    'NamespaceResourceQuota',
    'NamespaceResourceQuotaLimit',
    'NodePoolNodeTaint',
    'NodeTemplateAmazonec2Config',
    'NodeTemplateAzureConfig',
    'NodeTemplateDigitaloceanConfig',
    'NodeTemplateLinodeConfig',
    'NodeTemplateOpennebulaConfig',
    'NodeTemplateOpenstackConfig',
    'NodeTemplateVsphereConfig',
    'NotifierPagerdutyConfig',
    'NotifierSlackConfig',
    'NotifierSmtpConfig',
    'NotifierWebhookConfig',
    'NotifierWechatConfig',
    'PodSecurityPolicyTemplateAllowedCsiDriver',
    'PodSecurityPolicyTemplateAllowedFlexVolume',
    'PodSecurityPolicyTemplateAllowedHostPath',
    'PodSecurityPolicyTemplateFsGroup',
    'PodSecurityPolicyTemplateFsGroupRange',
    'PodSecurityPolicyTemplateHostPort',
    'PodSecurityPolicyTemplateRunAsGroup',
    'PodSecurityPolicyTemplateRunAsGroupRange',
    'PodSecurityPolicyTemplateRunAsUser',
    'PodSecurityPolicyTemplateRunAsUserRange',
    'PodSecurityPolicyTemplateRuntimeClass',
    'PodSecurityPolicyTemplateSeLinux',
    'PodSecurityPolicyTemplateSeLinuxSeLinuxOption',
    'PodSecurityPolicyTemplateSupplementalGroup',
    'PodSecurityPolicyTemplateSupplementalGroupRange',
    'ProjectAlertGroupRecipient',
    'ProjectAlertRuleMetricRule',
    'ProjectAlertRulePodRule',
    'ProjectAlertRuleWorkloadRule',
    'ProjectContainerResourceLimit',
    'ProjectLoggingCustomTargetConfig',
    'ProjectLoggingElasticsearchConfig',
    'ProjectLoggingFluentdConfig',
    'ProjectLoggingFluentdConfigFluentServer',
    'ProjectLoggingKafkaConfig',
    'ProjectLoggingSplunkConfig',
    'ProjectLoggingSyslogConfig',
    'ProjectProjectMonitoringInput',
    'ProjectResourceQuota',
    'ProjectResourceQuotaNamespaceDefaultLimit',
    'ProjectResourceQuotaProjectLimit',
    'RegistryRegistry',
    'RoleTempalteRule',
    'GetClusterAksConfigResult',
    'GetClusterAlertGroupRecipientResult',
    'GetClusterAlterRuleEventRuleResult',
    'GetClusterAlterRuleMetricRuleResult',
    'GetClusterAlterRuleNodeRuleResult',
    'GetClusterAlterRuleSystemServiceRuleResult',
    'GetClusterClusterAuthEndpointResult',
    'GetClusterClusterMonitoringInputResult',
    'GetClusterClusterRegistrationTokenResult',
    'GetClusterClusterTemplateAnswersResult',
    'GetClusterClusterTemplateQuestionResult',
    'GetClusterEksConfigResult',
    'GetClusterGkeConfigResult',
    'GetClusterK3sConfigResult',
    'GetClusterK3sConfigUpgradeStrategyResult',
    'GetClusterLoggingCustomTargetConfigResult',
    'GetClusterLoggingElasticsearchConfigResult',
    'GetClusterLoggingFluentdConfigResult',
    'GetClusterLoggingFluentdConfigFluentServerResult',
    'GetClusterLoggingKafkaConfigResult',
    'GetClusterLoggingSplunkConfigResult',
    'GetClusterLoggingSyslogConfigResult',
    'GetClusterRkeConfigResult',
    'GetClusterRkeConfigAuthenticationResult',
    'GetClusterRkeConfigAuthorizationResult',
    'GetClusterRkeConfigBastionHostResult',
    'GetClusterRkeConfigCloudProviderResult',
    'GetClusterRkeConfigCloudProviderAwsCloudProviderResult',
    'GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult',
    'GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult',
    'GetClusterRkeConfigCloudProviderAzureCloudProviderResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult',
    'GetClusterRkeConfigDnsResult',
    'GetClusterRkeConfigDnsNodelocalResult',
    'GetClusterRkeConfigIngressResult',
    'GetClusterRkeConfigMonitoringResult',
    'GetClusterRkeConfigMonitoringUpdateStrategyResult',
    'GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult',
    'GetClusterRkeConfigNetworkResult',
    'GetClusterRkeConfigNetworkCalicoNetworkProviderResult',
    'GetClusterRkeConfigNetworkCanalNetworkProviderResult',
    'GetClusterRkeConfigNetworkFlannelNetworkProviderResult',
    'GetClusterRkeConfigNetworkWeaveNetworkProviderResult',
    'GetClusterRkeConfigNodeResult',
    'GetClusterRkeConfigPrivateRegistryResult',
    'GetClusterRkeConfigServicesResult',
    'GetClusterRkeConfigServicesEtcdResult',
    'GetClusterRkeConfigServicesEtcdBackupConfigResult',
    'GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult',
    'GetClusterRkeConfigServicesKubeApiResult',
    'GetClusterRkeConfigServicesKubeApiAuditLogResult',
    'GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult',
    'GetClusterRkeConfigServicesKubeApiEventRateLimitResult',
    'GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult',
    'GetClusterRkeConfigServicesKubeControllerResult',
    'GetClusterRkeConfigServicesKubeletResult',
    'GetClusterRkeConfigServicesKubeproxyResult',
    'GetClusterRkeConfigServicesSchedulerResult',
    'GetClusterRkeConfigUpgradeStrategyResult',
    'GetClusterRkeConfigUpgradeStrategyDrainInputResult',
    'GetClusterScanScanConfigResult',
    'GetClusterScanScanConfigCisScanConfigResult',
    'GetClusterScheduledClusterScanResult',
    'GetClusterScheduledClusterScanScanConfigResult',
    'GetClusterScheduledClusterScanScanConfigCisScanConfigResult',
    'GetClusterScheduledClusterScanScheduleConfigResult',
    'GetClusterTemplateMemberResult',
    'GetClusterTemplateTemplateRevisionResult',
    'GetClusterTemplateTemplateRevisionClusterConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigResult',
    'GetClusterTemplateTemplateRevisionQuestionResult',
    'GetEtcdBackupBackupConfigResult',
    'GetEtcdBackupBackupConfigS3BackupConfigResult',
    'GetMultiClusterAppAnswerResult',
    'GetMultiClusterAppMemberResult',
    'GetMultiClusterAppTargetResult',
    'GetMultiClusterAppUpgradeStrategyResult',
    'GetMultiClusterAppUpgradeStrategyRollingUpdateResult',
    'GetNamespaceContainerResourceLimitResult',
    'GetNamespaceResourceQuotaResult',
    'GetNamespaceResourceQuotaLimitResult',
    'GetNodePoolNodeTaintResult',
    'GetNotifierPagerdutyConfigResult',
    'GetNotifierSlackConfigResult',
    'GetNotifierSmtpConfigResult',
    'GetNotifierWebhookConfigResult',
    'GetNotifierWechatConfigResult',
    'GetPodSecurityPolicyTemplateAllowedCsiDriverResult',
    'GetPodSecurityPolicyTemplateAllowedFlexVolumeResult',
    'GetPodSecurityPolicyTemplateAllowedHostPathResult',
    'GetPodSecurityPolicyTemplateFsGroupResult',
    'GetPodSecurityPolicyTemplateFsGroupRangeResult',
    'GetPodSecurityPolicyTemplateHostPortResult',
    'GetPodSecurityPolicyTemplateRunAsGroupResult',
    'GetPodSecurityPolicyTemplateRunAsGroupRangeResult',
    'GetPodSecurityPolicyTemplateRunAsUserResult',
    'GetPodSecurityPolicyTemplateRunAsUserRangeResult',
    'GetPodSecurityPolicyTemplateRuntimeClassResult',
    'GetPodSecurityPolicyTemplateSeLinuxResult',
    'GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult',
    'GetPodSecurityPolicyTemplateSupplementalGroupResult',
    'GetPodSecurityPolicyTemplateSupplementalGroupRangeResult',
    'GetProjectAlertGroupRecipientResult',
    'GetProjectAlertRuleMetricRuleResult',
    'GetProjectAlertRulePodRuleResult',
    'GetProjectAlertRuleWorkloadRuleResult',
    'GetProjectContainerResourceLimitResult',
    'GetProjectLoggingCustomTargetConfigResult',
    'GetProjectLoggingElasticsearchConfigResult',
    'GetProjectLoggingFluentdConfigResult',
    'GetProjectLoggingFluentdConfigFluentServerResult',
    'GetProjectLoggingKafkaConfigResult',
    'GetProjectLoggingSplunkConfigResult',
    'GetProjectLoggingSyslogConfigResult',
    'GetProjectResourceQuotaResult',
    'GetProjectResourceQuotaNamespaceDefaultLimitResult',
    'GetProjectResourceQuotaProjectLimitResult',
    'GetRegistryRegistryResult',
    'GetRoleTempalteRuleResult',
    'GetRoleTemplateRuleResult',
]

@pulumi.output_type
class CloudCredentialAmazonec2CredentialConfig(dict):
    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str):
        """
        :param str access_key: AWS access key (string)
        :param str secret_key: AWS secret key (string)
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class CloudCredentialAzureCredentialConfig(dict):
    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str,
                 subscription_id: str):
        """
        :param str client_id: Azure Service Principal Account ID (string)
        :param str client_secret: Azure Service Principal Account password (string)
        :param str subscription_id: Azure Subscription ID (string)
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class CloudCredentialDigitaloceanCredentialConfig(dict):
    def __init__(__self__, *,
                 access_token: str):
        """
        :param str access_token: DigitalOcean access token (string)
        """
        pulumi.set(__self__, "access_token", access_token)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class CloudCredentialLinodeCredentialConfig(dict):
    def __init__(__self__, *,
                 token: str):
        """
        :param str token: Linode API token (string)
        """
        pulumi.set(__self__, "token", token)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class CloudCredentialOpenstackCredentialConfig(dict):
    def __init__(__self__, *,
                 password: str):
        """
        :param str password: vSphere password (string)
        """
        pulumi.set(__self__, "password", password)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigCloudProviderAwsCloudProvider(dict):
    def __init__(__self__, *,
                 global_: Optional['outputs.ClusterRkeConfigCloudProviderAwsCloudProviderGlobal'] = None,
                 service_overrides: Optional[List['outputs.ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride']] = None):
        """
        :param 'ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs' global_: (list maxitems:1)
        :param List['ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideArgs'] service_overrides: (list)
        """
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if service_overrides is not None:
            pulumi.set(__self__, "service_overrides", service_overrides)

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProvider(dict):
    def __init__(__self__, *,
                 global_: 'outputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal',
                 block_storage: Optional['outputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage'] = None,
                 load_balancer: Optional['outputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer'] = None,
                 metadata: Optional['outputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata'] = None,
                 route: Optional['outputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute'] = None):
        """
        :param 'ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalArgs' global_: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageArgs' block_storage: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerArgs' load_balancer: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataArgs' metadata: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderOpenstackCloudProviderRouteArgs' route: (list maxitems:1)
        """
        pulumi.set(__self__, "global_", global_)
        if block_storage is not None:
            pulumi.set(__self__, "block_storage", block_storage)
        if load_balancer is not None:
            pulumi.set(__self__, "load_balancer", load_balancer)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if route is not None:
            pulumi.set(__self__, "route", route)

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProvider(dict):
    def __init__(__self__, *,
                 virtual_centers: List['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter'],
                 workspace: 'outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace',
                 disk: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderDisk'] = None,
                 global_: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal'] = None,
                 network: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork'] = None):
        """
        :param List['ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterArgs'] virtual_centers: (List)
        :param 'ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceArgs' workspace: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderVsphereCloudProviderDiskArgs' disk: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderVsphereCloudProviderGlobalArgs' global_: (list maxitems:1)
        :param 'ClusterRkeConfigCloudProviderVsphereCloudProviderNetworkArgs' network: Network for GKE cluster (string)
        """
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if network is not None:
            pulumi.set(__self__, "network", network)

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

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace':
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "workspace")

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigDns(dict):
    def __init__(__self__, *,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 nodelocal: Optional['outputs.ClusterRkeConfigDnsNodelocal'] = None,
                 provider: Optional[str] = None,
                 reverse_cidrs: Optional[List[str]] = None,
                 upstream_nameservers: Optional[List[str]] = None):
        """
        :param Mapping[str, Any] node_selector: RKE monitoring node selector (map)
        :param 'ClusterRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns config  (list Maxitem: 1)
        :param str provider: RKE monitoring provider (string)
        :param List[str] reverse_cidrs: DNS add-on reverse cidr  (list)
        :param List[str] upstream_nameservers: DNS add-on upstream nameservers  (list)
        """
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional['outputs.ClusterRkeConfigDnsNodelocal']:
        """
        Nodelocal dns config  (list Maxitem: 1)
        """
        return pulumi.get(self, "nodelocal")

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

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[List[str]]:
        """
        DNS add-on reverse cidr  (list)
        """
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Optional[List[str]]:
        """
        DNS add-on upstream nameservers  (list)
        """
        return pulumi.get(self, "upstream_nameservers")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigDnsNodelocal(dict):
    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        """
        :param str ip_address: Nodelocal dns ip address (string)
        :param Mapping[str, Any] node_selector: RKE monitoring node selector (map)
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        """
        Nodelocal dns ip address (string)
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigIngress(dict):
    def __init__(__self__, *,
                 dns_policy: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None):
        """
        :param str dns_policy: Ingress controller DNS policy. `ClusterFirstWithHostNet`, `ClusterFirst`, `Default`, and `None` are supported. [K8S dns Policy](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy) (string)
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param Mapping[str, Any] node_selector: RKE monitoring node selector (map)
        :param Mapping[str, Any] options: RKE options for network (map)
        :param str provider: RKE monitoring provider (string)
        """
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> Optional[str]:
        """
        Ingress controller DNS policy. `ClusterFirstWithHostNet`, `ClusterFirst`, `Default`, and `None` are supported. [K8S dns Policy](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy) (string)
        """
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigMonitoring(dict):
    def __init__(__self__, *,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 replicas: Optional[float] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategy'] = None):
        """
        :param Mapping[str, Any] node_selector: RKE monitoring node selector (map)
        :param Mapping[str, Any] options: RKE options for network (map)
        :param str provider: RKE monitoring provider (string)
        :param float replicas: RKE monitoring replicas (int)
        :param 'ClusterRkeConfigMonitoringUpdateStrategyArgs' update_strategy: RKE monitoring update strategy (list Maxitems: 1)
        """
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

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

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

    @property
    @pulumi.getter
    def replicas(self) -> Optional[float]:
        """
        RKE monitoring replicas (int)
        """
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategy']:
        """
        RKE monitoring update strategy (list Maxitems: 1)
        """
        return pulumi.get(self, "update_strategy")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigMonitoringUpdateStrategy(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Monitoring deployment rolling update (list Maxitems: 1)
        :param str strategy: Monitoring deployment update strategy (string)
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate']:
        """
        Monitoring deployment rolling update (list Maxitems: 1)
        """
        return pulumi.get(self, "rolling_update")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate(dict):
    def __init__(__self__, *,
                 max_surge: Optional[float] = None,
                 max_unavailable: Optional[float] = None):
        """
        :param float max_surge: Monitoring deployment rolling update max surge. Default: `1` (int)
        :param float max_unavailable: Monitoring deployment rolling update max unavailable. Default: `1` (int)
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[float]:
        """
        Monitoring deployment rolling update max surge. Default: `1` (int)
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[float]:
        """
        Monitoring deployment rolling update max unavailable. Default: `1` (int)
        """
        return pulumi.get(self, "max_unavailable")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigNetwork(dict):
    def __init__(__self__, *,
                 calico_network_provider: Optional['outputs.ClusterRkeConfigNetworkCalicoNetworkProvider'] = None,
                 canal_network_provider: Optional['outputs.ClusterRkeConfigNetworkCanalNetworkProvider'] = None,
                 flannel_network_provider: Optional['outputs.ClusterRkeConfigNetworkFlannelNetworkProvider'] = None,
                 mtu: Optional[float] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 plugin: Optional[str] = None,
                 weave_network_provider: Optional['outputs.ClusterRkeConfigNetworkWeaveNetworkProvider'] = None):
        """
        :param 'ClusterRkeConfigNetworkCalicoNetworkProviderArgs' calico_network_provider: Calico provider config for RKE network (list maxitems:1)
        :param 'ClusterRkeConfigNetworkCanalNetworkProviderArgs' canal_network_provider: Canal provider config for RKE network (list maxitems:1)
        :param 'ClusterRkeConfigNetworkFlannelNetworkProviderArgs' flannel_network_provider: Flannel provider config for RKE network (list maxitems:1)
        :param float mtu: Network provider MTU. Default `0` (int)
        :param Mapping[str, Any] options: RKE options for network (map)
        :param str plugin: Plugin for RKE network. `canal` (default), `flannel`, `calico`, `none` and `weave` are supported. (string)
        :param 'ClusterRkeConfigNetworkWeaveNetworkProviderArgs' weave_network_provider: Weave provider config for RKE network (list maxitems:1)
        """
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkCalicoNetworkProvider']:
        """
        Calico provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "calico_network_provider")

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkCanalNetworkProvider']:
        """
        Canal provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "canal_network_provider")

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkFlannelNetworkProvider']:
        """
        Flannel provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "flannel_network_provider")

    @property
    @pulumi.getter
    def mtu(self) -> Optional[float]:
        """
        Network provider MTU. Default `0` (int)
        """
        return pulumi.get(self, "mtu")

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

    @property
    @pulumi.getter
    def plugin(self) -> Optional[str]:
        """
        Plugin for RKE network. `canal` (default), `flannel`, `calico`, `none` and `weave` are supported. (string)
        """
        return pulumi.get(self, "plugin")

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkWeaveNetworkProvider']:
        """
        Weave provider config for RKE network (list maxitems:1)
        """
        return pulumi.get(self, "weave_network_provider")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigNetworkCalicoNetworkProvider(dict):
    def __init__(__self__, *,
                 cloud_provider: Optional[str] = None):
        """
        :param str cloud_provider: RKE options for Calico network provider (string)
        """
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigNetworkCanalNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[str] = None):
        """
        :param str iface: Iface config Flannel network provider (string)
        """
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[str]:
        """
        Iface config Flannel network provider (string)
        """
        return pulumi.get(self, "iface")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigNetworkFlannelNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[str] = None):
        """
        :param str iface: Iface config Flannel network provider (string)
        """
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[str]:
        """
        Iface config Flannel network provider (string)
        """
        return pulumi.get(self, "iface")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigNetworkWeaveNetworkProvider(dict):
    def __init__(__self__, *,
                 password: str):
        """
        :param str password: Registry password (string)
        """
        pulumi.set(__self__, "password", password)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigNode(dict):
    def __init__(__self__, *,
                 address: str,
                 roles: List[str],
                 user: str,
                 docker_socket: Optional[str] = None,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[str] = None):
        """
        :param str address: Address ip for node (string)
        :param List[str] roles: Roles for the node. `controlplane`, `etcd` and `worker` are supported. (list)
        :param str user: Registry user (string)
        :param str docker_socket: Docker socket for node (string)
        :param str hostname_override: Hostname override for node (string)
        :param str internal_address: Internal ip for node (string)
        :param Mapping[str, Any] labels: Labels for cluster registration token object (map)
        :param str node_id: Id for the node (string)
        :param str port: Port for node. Default `22` (string)
        :param bool ssh_agent_auth: Use ssh agent auth. Default `false` (bool)
        :param str ssh_key: Node SSH private key (string)
        :param str ssh_key_path: Node SSH private key path (string)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

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

    @property
    @pulumi.getter
    def roles(self) -> List[str]:
        """
        Roles for the node. `controlplane`, `etcd` and `worker` are supported. (list)
        """
        return pulumi.get(self, "roles")

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

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> Optional[str]:
        """
        Docker socket for node (string)
        """
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[str]:
        """
        Hostname override for node (string)
        """
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[str]:
        """
        Internal ip for node (string)
        """
        return pulumi.get(self, "internal_address")

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigPrivateRegistry(dict):
    def __init__(__self__, *,
                 url: str,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :param str url: Registry URL (string)
        :param bool is_default: Set as default registry. Default `false` (bool)
        :param str password: Registry password (string)
        :param str user: Registry user (string)
        """
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[bool]:
        """
        Set as default registry. Default `false` (bool)
        """
        return pulumi.get(self, "is_default")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServices(dict):
    def __init__(__self__, *,
                 etcd: Optional['outputs.ClusterRkeConfigServicesEtcd'] = None,
                 kube_api: Optional['outputs.ClusterRkeConfigServicesKubeApi'] = None,
                 kube_controller: Optional['outputs.ClusterRkeConfigServicesKubeController'] = None,
                 kubelet: Optional['outputs.ClusterRkeConfigServicesKubelet'] = None,
                 kubeproxy: Optional['outputs.ClusterRkeConfigServicesKubeproxy'] = None,
                 scheduler: Optional['outputs.ClusterRkeConfigServicesScheduler'] = None):
        """
        :param 'ClusterRkeConfigServicesEtcdArgs' etcd: Etcd options for RKE services (list maxitems:1)
        :param 'ClusterRkeConfigServicesKubeApiArgs' kube_api: Kube API options for RKE services (list maxitems:1)
        :param 'ClusterRkeConfigServicesKubeControllerArgs' kube_controller: Kube Controller options for RKE services (list maxitems:1)
        :param 'ClusterRkeConfigServicesKubeletArgs' kubelet: Kubelet options for RKE services (list maxitems:1)
        :param 'ClusterRkeConfigServicesKubeproxyArgs' kubeproxy: Kubeproxy options for RKE services (list maxitems:1)
        :param 'ClusterRkeConfigServicesSchedulerArgs' scheduler: Scheduler options for RKE services (list maxitems:1)
        """
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if kube_api is not None:
            pulumi.set(__self__, "kube_api", kube_api)
        if kube_controller is not None:
            pulumi.set(__self__, "kube_controller", kube_controller)
        if kubelet is not None:
            pulumi.set(__self__, "kubelet", kubelet)
        if kubeproxy is not None:
            pulumi.set(__self__, "kubeproxy", kubeproxy)
        if scheduler is not None:
            pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> Optional['outputs.ClusterRkeConfigServicesEtcd']:
        """
        Etcd options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApi']:
        """
        Kube API options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> Optional['outputs.ClusterRkeConfigServicesKubeController']:
        """
        Kube Controller options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> Optional['outputs.ClusterRkeConfigServicesKubelet']:
        """
        Kubelet options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> Optional['outputs.ClusterRkeConfigServicesKubeproxy']:
        """
        Kubeproxy options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> Optional['outputs.ClusterRkeConfigServicesScheduler']:
        """
        Scheduler options for RKE services (list maxitems:1)
        """
        return pulumi.get(self, "scheduler")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesEtcd(dict):
    def __init__(__self__, *,
                 backup_config: Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfig'] = None,
                 ca_cert: Optional[str] = None,
                 cert: Optional[str] = None,
                 creation: Optional[str] = None,
                 external_urls: Optional[List[str]] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 gid: Optional[float] = None,
                 image: Optional[str] = None,
                 key: Optional[str] = None,
                 path: Optional[str] = None,
                 retention: Optional[str] = None,
                 snapshot: Optional[bool] = None,
                 uid: Optional[float] = None):
        """
        :param 'ClusterRkeConfigServicesEtcdBackupConfigArgs' backup_config: Backup options for etcd service. Just for Rancher v2.2.x (list maxitems:1)
        :param str ca_cert: TLS CA certificate for etcd service (string)
        :param str cert: TLS certificate for etcd service (string)
        :param str creation: Creation option for etcd service (string)
        :param List[str] external_urls: External urls for etcd service (list)
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param List[str] extra_binds: Extra binds for scheduler service (list)
        :param List[str] extra_envs: Extra environment for scheduler service (list)
        :param float gid: Etcd service GID. Default: `0`. For Rancher v2.3.x or above (int)
        :param str image: Docker image for scheduler service (string)
        :param str key: TLS key for etcd service (string)
        :param str path: (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        :param str retention: Retention for etcd backup. Default `6` (int)
        :param bool snapshot: Snapshot option for etcd service (bool)
        :param float uid: Etcd service UID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfig']:
        """
        Backup options for etcd service. Just for Rancher v2.2.x (list maxitems:1)
        """
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> Optional[str]:
        """
        TLS CA certificate for etcd service (string)
        """
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> Optional[str]:
        """
        TLS certificate for etcd service (string)
        """
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> Optional[str]:
        """
        Creation option for etcd service (string)
        """
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[List[str]]:
        """
        External urls for etcd service (list)
        """
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[float]:
        """
        Etcd service GID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        TLS key for etcd service (string)
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> Optional[str]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> Optional[bool]:
        """
        Snapshot option for etcd service (bool)
        """
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter
    def uid(self) -> Optional[float]:
        """
        Etcd service UID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        return pulumi.get(self, "uid")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesEtcdBackupConfig(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[float] = None,
                 retention: Optional[float] = None,
                 s3_backup_config: Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None):
        """
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        :param float interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param float retention: Retention for etcd backup. Default `6` (int)
        :param 'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs' s3_backup_config: S3 config options for etcd backup (list maxitems:1)
        :param bool safe_timestamp: Safe timestamp for etcd backup. Default: `false` (bool)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

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

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[float]:
        """
        Interval hours for etcd backup. Default `12` (int)
        """
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[float]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig']:
        """
        S3 config options for etcd backup (list maxitems:1)
        """
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        """
        Safe timestamp for etcd backup. Default: `false` (bool)
        """
        return pulumi.get(self, "safe_timestamp")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        """
        :param str bucket_name: Bucket name for S3 service (string)
        :param str endpoint: Endpoint for S3 service (string)
        :param str access_key: The AWS Client ID to use (string)
        :param str custom_ca: Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        :param str folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param str region: GKE cluster region. Conflicts with `zone` (string)
        :param str secret_key: The AWS Client Secret associated with the Client ID (string)
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        """
        Bucket name for S3 service (string)
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        Endpoint for S3 service (string)
        """
        return pulumi.get(self, "endpoint")

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

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        """
        Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        """
        return pulumi.get(self, "custom_ca")

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeApi(dict):
    def __init__(__self__, *,
                 admission_configuration: Optional[Mapping[str, Any]] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLog'] = None,
                 event_rate_limit: Optional['outputs.ClusterRkeConfigServicesKubeApiEventRateLimit'] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[str] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig'] = None,
                 service_cluster_ip_range: Optional[str] = None,
                 service_node_port_range: Optional[str] = None):
        """
        :param Mapping[str, Any] admission_configuration: Admission configuration (map)
        :param bool always_pull_images: Enable [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages) Admission controller plugin. [Rancher docs](https://rancher.com/docs/rke/latest/en/config-options/services/#kubernetes-api-server-options) Default: `false` (bool)
        :param 'ClusterRkeConfigServicesKubeApiAuditLogArgs' audit_log: K8s audit log configuration. (list maxitems: 1)
        :param 'ClusterRkeConfigServicesKubeApiEventRateLimitArgs' event_rate_limit: K8s event rate limit configuration. (list maxitems: 1)
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param List[str] extra_binds: Extra binds for scheduler service (list)
        :param List[str] extra_envs: Extra environment for scheduler service (list)
        :param str image: Docker image for scheduler service (string)
        :param bool pod_security_policy: Pod Security Policy option for kube API service. Default `false` (bool)
        :param 'ClusterRkeConfigServicesKubeApiSecretsEncryptionConfigArgs' secrets_encryption_config: [Encrypt k8s secret data configration](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/). (list maxitem: 1)
        :param str service_cluster_ip_range: Service Cluster ip Range option for kube controller service (string)
        :param str service_node_port_range: Service Node Port Range option for kube API service (string)
        """
        if admission_configuration is not None:
            pulumi.set(__self__, "admission_configuration", admission_configuration)
        if always_pull_images is not None:
            pulumi.set(__self__, "always_pull_images", always_pull_images)
        if audit_log is not None:
            pulumi.set(__self__, "audit_log", audit_log)
        if event_rate_limit is not None:
            pulumi.set(__self__, "event_rate_limit", event_rate_limit)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if service_node_port_range is not None:
            pulumi.set(__self__, "service_node_port_range", service_node_port_range)

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional[Mapping[str, Any]]:
        """
        Admission configuration (map)
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[bool]:
        """
        Enable [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages) Admission controller plugin. [Rancher docs](https://rancher.com/docs/rke/latest/en/config-options/services/#kubernetes-api-server-options) Default: `false` (bool)
        """
        return pulumi.get(self, "always_pull_images")

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLog']:
        """
        K8s audit log configuration. (list maxitems: 1)
        """
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiEventRateLimit']:
        """
        K8s event rate limit configuration. (list maxitems: 1)
        """
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[bool]:
        """
        Pod Security Policy option for kube API service. Default `false` (bool)
        """
        return pulumi.get(self, "pod_security_policy")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig']:
        """
        [Encrypt k8s secret data configration](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/). (list maxitem: 1)
        """
        return pulumi.get(self, "secrets_encryption_config")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[str]:
        """
        Service Cluster ip Range option for kube controller service (string)
        """
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> Optional[str]:
        """
        Service Node Port Range option for kube API service (string)
        """
        return pulumi.get(self, "service_node_port_range")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiAuditLog(dict):
    def __init__(__self__, *,
                 configuration: Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLogConfiguration'] = None,
                 enabled: Optional[bool] = None):
        """
        :param 'ClusterRkeConfigServicesKubeApiAuditLogConfigurationArgs' configuration: Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLogConfiguration']:
        """
        Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        """
        return pulumi.get(self, "configuration")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiAuditLogConfiguration(dict):
    def __init__(__self__, *,
                 format: Optional[str] = None,
                 max_age: Optional[float] = None,
                 max_backup: Optional[float] = None,
                 max_size: Optional[float] = None,
                 path: Optional[str] = None,
                 policy: Optional[str] = None):
        """
        :param str format: Audit log format. Default: 'json' (string)
        :param float max_age: Audit log max age. Default: `30` (int)
        :param float max_backup: Audit log max backup. Default: `10` (int)
        :param float max_size: Audit log max size. Default: `100` (int)
        :param str path: (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        :param str policy: Audit policy yaml encoded definition. `apiVersion` and `kind: Policy\nrules:"` fields are required in the yaml. Ex. `"apiVersion: audit.k8s.io/v1\nkind: Policy\nrules:\n- level: RequestResponse\n  resources:\n  - resources:\n    - pods\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string)
        """
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        """
        Audit log format. Default: 'json' (string)
        """
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[float]:
        """
        Audit log max age. Default: `30` (int)
        """
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[float]:
        """
        Audit log max backup. Default: `10` (int)
        """
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[float]:
        """
        Audit log max size. Default: `100` (int)
        """
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        """
        Audit policy yaml encoded definition. `apiVersion` and `kind: Policy\nrules:"` fields are required in the yaml. Ex. `"apiVersion: audit.k8s.io/v1\nkind: Policy\nrules:\n- level: RequestResponse\n  resources:\n  - resources:\n    - pods\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string)
        """
        return pulumi.get(self, "policy")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiEventRateLimit(dict):
    def __init__(__self__, *,
                 configuration: Optional[str] = None,
                 enabled: Optional[bool] = None):
        """
        :param str configuration: Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[str]:
        """
        Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. Ex. `"apiVersion: eventratelimit.admission.k8s.io/v1alpha1\nkind: Configuration\nlimits:\n- type: Server\n  burst: 35000\n  qps: 6000\n"` [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string)
        """
        return pulumi.get(self, "configuration")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig(dict):
    def __init__(__self__, *,
                 custom_config: Optional[str] = None,
                 enabled: Optional[bool] = None):
        """
        :param str custom_config: Secrets encryption yaml encoded custom configuration. `"apiVersion"` and `"kind":"EncryptionConfiguration"` fields are required in the yaml. Ex. `apiVersion: apiserver.config.k8s.io/v1\nkind: EncryptionConfiguration\nresources:\n- resources:\n  - secrets\n  providers:\n  - aescbc:\n      keys:\n      - name: k-fw5hn\n        secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=\n    identity: {}\n` [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string)
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        if custom_config is not None:
            pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="customConfig")
    def custom_config(self) -> Optional[str]:
        """
        Secrets encryption yaml encoded custom configuration. `"apiVersion"` and `"kind":"EncryptionConfiguration"` fields are required in the yaml. Ex. `apiVersion: apiserver.config.k8s.io/v1\nkind: EncryptionConfiguration\nresources:\n- resources:\n  - secrets\n  providers:\n  - aescbc:\n      keys:\n      - name: k-fw5hn\n        secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=\n    identity: {}\n` [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string)
        """
        return pulumi.get(self, "custom_config")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeController(dict):
    def __init__(__self__, *,
                 cluster_cidr: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[str] = None,
                 service_cluster_ip_range: Optional[str] = None):
        """
        :param str cluster_cidr: Cluster CIDR option for kube controller service (string)
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param List[str] extra_binds: Extra binds for scheduler service (list)
        :param List[str] extra_envs: Extra environment for scheduler service (list)
        :param str image: Docker image for scheduler service (string)
        :param str service_cluster_ip_range: Service Cluster ip Range option for kube controller service (string)
        """
        if cluster_cidr is not None:
            pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> Optional[str]:
        """
        Cluster CIDR option for kube controller service (string)
        """
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[str]:
        """
        Service Cluster ip Range option for kube controller service (string)
        """
        return pulumi.get(self, "service_cluster_ip_range")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubelet(dict):
    def __init__(__self__, *,
                 cluster_dns_server: Optional[str] = None,
                 cluster_domain: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 fail_swap_on: Optional[bool] = None,
                 generate_serving_certificate: Optional[bool] = None,
                 image: Optional[str] = None,
                 infra_container_image: Optional[str] = None):
        """
        :param str cluster_dns_server: Cluster DNS Server option for kubelet service (string)
        :param str cluster_domain: Cluster Domain option for kubelet service (string)
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param List[str] extra_binds: Extra binds for scheduler service (list)
        :param List[str] extra_envs: Extra environment for scheduler service (list)
        :param bool fail_swap_on: Enable or disable failing when swap on is not supported (bool)
        :param bool generate_serving_certificate: [Generate a certificate signed by the kube-ca](https://rancher.com/docs/rke/latest/en/config-options/services/#kubelet-serving-certificate-requirements). Default `false` (bool)
        :param str image: Docker image for scheduler service (string)
        :param str infra_container_image: Infra container image for kubelet service (string)
        """
        if cluster_dns_server is not None:
            pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        if cluster_domain is not None:
            pulumi.set(__self__, "cluster_domain", cluster_domain)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if fail_swap_on is not None:
            pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if infra_container_image is not None:
            pulumi.set(__self__, "infra_container_image", infra_container_image)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> Optional[str]:
        """
        Cluster DNS Server option for kubelet service (string)
        """
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> Optional[str]:
        """
        Cluster Domain option for kubelet service (string)
        """
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> Optional[bool]:
        """
        Enable or disable failing when swap on is not supported (bool)
        """
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[bool]:
        """
        [Generate a certificate signed by the kube-ca](https://rancher.com/docs/rke/latest/en/config-options/services/#kubelet-serving-certificate-requirements). Default `false` (bool)
        """
        return pulumi.get(self, "generate_serving_certificate")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> Optional[str]:
        """
        Infra container image for kubelet service (string)
        """
        return pulumi.get(self, "infra_container_image")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesKubeproxy(dict):
    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[str] = None):
        """
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param List[str] extra_binds: Extra binds for scheduler service (list)
        :param List[str] extra_envs: Extra environment for scheduler service (list)
        :param str image: Docker image for scheduler service (string)
        """
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigServicesScheduler(dict):
    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[str] = None):
        """
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param List[str] extra_binds: Extra binds for scheduler service (list)
        :param List[str] extra_envs: Extra environment for scheduler service (list)
        :param str image: Docker image for scheduler service (string)
        """
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        """
        Extra environment for scheduler service (list)
        """
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigUpgradeStrategy(dict):
    def __init__(__self__, *,
                 drain: Optional[bool] = None,
                 drain_input: Optional['outputs.ClusterRkeConfigUpgradeStrategyDrainInput'] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        """
        :param bool drain: RKE drain nodes. Default: `false` (bool)
        :param 'ClusterRkeConfigUpgradeStrategyDrainInputArgs' drain_input: RKE drain node input (list Maxitems: 1)
        :param str max_unavailable_controlplane: RKE max unavailable controlplane nodes. Default: `1` (string)
        :param str max_unavailable_worker: RKE max unavailable worker nodes. Default: `10%` (string)
        """
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if drain_input is not None:
            pulumi.set(__self__, "drain_input", drain_input)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

    @property
    @pulumi.getter
    def drain(self) -> Optional[bool]:
        """
        RKE drain nodes. Default: `false` (bool)
        """
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> Optional['outputs.ClusterRkeConfigUpgradeStrategyDrainInput']:
        """
        RKE drain node input (list Maxitems: 1)
        """
        return pulumi.get(self, "drain_input")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[str]:
        """
        RKE max unavailable controlplane nodes. Default: `1` (string)
        """
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[str]:
        """
        RKE max unavailable worker nodes. Default: `10%` (string)
        """
        return pulumi.get(self, "max_unavailable_worker")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterRkeConfigUpgradeStrategyDrainInput(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[float] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[float] = None):
        """
        :param bool delete_local_data: Delete RKE node local data. Default: `false` (bool)
        :param bool force: Force RKE node drain. Default: `false` (bool)
        :param float grace_period: RKE node drain grace period. Default: `-1` (int)
        :param bool ignore_daemon_sets: Ignore RKE daemon sets. Default: `true` (bool)
        :param float timeout: RKE node drain timeout. Default: `60` (int)
        """
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[bool]:
        """
        Delete RKE node local data. Default: `false` (bool)
        """
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        """
        Force RKE node drain. Default: `false` (bool)
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[float]:
        """
        RKE node drain grace period. Default: `-1` (int)
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        """
        Ignore RKE daemon sets. Default: `true` (bool)
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[float]:
        """
        RKE node drain timeout. Default: `60` (int)
        """
        return pulumi.get(self, "timeout")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterScheduledClusterScan(dict):
    def __init__(__self__, *,
                 scan_config: 'outputs.ClusterScheduledClusterScanScanConfig',
                 schedule_config: 'outputs.ClusterScheduledClusterScanScheduleConfig',
                 enabled: Optional[bool] = None):
        """
        :param 'ClusterScheduledClusterScanScanConfigArgs' scan_config: Cluster scan config (List maxitems:1)
        :param 'ClusterScheduledClusterScanScheduleConfigArgs' schedule_config: Cluster scan schedule config (list maxitems:1)
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        pulumi.set(__self__, "scan_config", scan_config)
        pulumi.set(__self__, "schedule_config", schedule_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="scanConfig")
    def scan_config(self) -> 'outputs.ClusterScheduledClusterScanScanConfig':
        """
        Cluster scan config (List maxitems:1)
        """
        return pulumi.get(self, "scan_config")

    @property
    @pulumi.getter(name="scheduleConfig")
    def schedule_config(self) -> 'outputs.ClusterScheduledClusterScanScheduleConfig':
        """
        Cluster scan schedule config (list maxitems:1)
        """
        return pulumi.get(self, "schedule_config")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterScheduledClusterScanScanConfig(dict):
    def __init__(__self__, *,
                 cis_scan_config: Optional['outputs.ClusterScheduledClusterScanScanConfigCisScanConfig'] = None):
        """
        :param 'ClusterScheduledClusterScanScanConfigCisScanConfigArgs' cis_scan_config: Cluster Cis Scan config (List maxitems:1)
        """
        if cis_scan_config is not None:
            pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> Optional['outputs.ClusterScheduledClusterScanScanConfigCisScanConfig']:
        """
        Cluster Cis Scan config (List maxitems:1)
        """
        return pulumi.get(self, "cis_scan_config")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterScheduledClusterScanScanConfigCisScanConfig(dict):
    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[List[str]] = None,
                 profile: Optional[str] = None):
        """
        :param bool debug_master: Debug master. Default: `false` (bool)
        :param bool debug_worker: Debug worker. Default: `false` (bool)
        :param str override_benchmark_version: Override benchmark version (string)
        :param List[str] override_skips: Override skip (string)
        :param str profile: Cis scan profile. Allowed values: `"permissive" (default) || "hardened"` (string)
        """
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="debugMaster")
    def debug_master(self) -> Optional[bool]:
        """
        Debug master. Default: `false` (bool)
        """
        return pulumi.get(self, "debug_master")

    @property
    @pulumi.getter(name="debugWorker")
    def debug_worker(self) -> Optional[bool]:
        """
        Debug worker. Default: `false` (bool)
        """
        return pulumi.get(self, "debug_worker")

    @property
    @pulumi.getter(name="overrideBenchmarkVersion")
    def override_benchmark_version(self) -> Optional[str]:
        """
        Override benchmark version (string)
        """
        return pulumi.get(self, "override_benchmark_version")

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[List[str]]:
        """
        Override skip (string)
        """
        return pulumi.get(self, "override_skips")

    @property
    @pulumi.getter
    def profile(self) -> Optional[str]:
        """
        Cis scan profile. Allowed values: `"permissive" (default) || "hardened"` (string)
        """
        return pulumi.get(self, "profile")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterScheduledClusterScanScheduleConfig(dict):
    def __init__(__self__, *,
                 cron_schedule: str,
                 retention: Optional[float] = None):
        """
        :param str cron_schedule: Crontab schedule. It should contains 5 fields `"<min> <hour> <month_day> <month> <week_day>"` (string)
        :param float retention: Retention for etcd backup. Default `6` (int)
        """
        pulumi.set(__self__, "cron_schedule", cron_schedule)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)

    @property
    @pulumi.getter(name="cronSchedule")
    def cron_schedule(self) -> str:
        """
        Crontab schedule. It should contains 5 fields `"<min> <hour> <month_day> <month> <week_day>"` (string)
        """
        return pulumi.get(self, "cron_schedule")

    @property
    @pulumi.getter
    def retention(self) -> Optional[float]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateMember(dict):
    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        """
        :param str access_type: Member access type. Valid values: `["read-only" | "owner"]` (string)
        :param str group_principal_id: Member group principal id (string)
        :param str user_principal_id: Member user principal id (string)
        """
        if access_type is not None:
            pulumi.set(__self__, "access_type", access_type)
        if group_principal_id is not None:
            pulumi.set(__self__, "group_principal_id", group_principal_id)
        if user_principal_id is not None:
            pulumi.set(__self__, "user_principal_id", user_principal_id)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> Optional[str]:
        """
        Member access type. Valid values: `["read-only" | "owner"]` (string)
        """
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[str]:
        """
        Member group principal id (string)
        """
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        """
        Member user principal id (string)
        """
        return pulumi.get(self, "user_principal_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevision(dict):
    def __init__(__self__, *,
                 cluster_config: 'outputs.ClusterTemplateTemplateRevisionClusterConfig',
                 name: str,
                 annotations: Optional[Mapping[str, Any]] = None,
                 cluster_template_id: Optional[str] = None,
                 default: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 id: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 questions: Optional[List['outputs.ClusterTemplateTemplateRevisionQuestion']] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigArgs' cluster_config: Cluster configuration (list maxitem: 1)
        :param str name: The cluster template revision name (string)
        :param Mapping[str, Any] annotations: Annotations for the cluster template revision (map)
        :param str cluster_template_id: Cluster template ID (string)
        :param bool default: Default variable value (string)
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        :param str id: The cluster template revision ID (string)
        :param Mapping[str, Any] labels: Labels for the cluster template revision (map)
        :param List['ClusterTemplateTemplateRevisionQuestionArgs'] questions: Cluster template questions (list)
        """
        pulumi.set(__self__, "cluster_config", cluster_config)
        pulumi.set(__self__, "name", name)
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_template_id is not None:
            pulumi.set(__self__, "cluster_template_id", cluster_template_id)
        if default is not None:
            pulumi.set(__self__, "default", default)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if questions is not None:
            pulumi.set(__self__, "questions", questions)

    @property
    @pulumi.getter(name="clusterConfig")
    def cluster_config(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfig':
        """
        Cluster configuration (list maxitem: 1)
        """
        return pulumi.get(self, "cluster_config")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template revision name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, Any]]:
        """
        Annotations for the cluster template revision (map)
        """
        return pulumi.get(self, "annotations")

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

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        The cluster template revision ID (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        Labels for the cluster template revision (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def questions(self) -> Optional[List['outputs.ClusterTemplateTemplateRevisionQuestion']]:
        """
        Cluster template questions (list)
        """
        return pulumi.get(self, "questions")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfig(dict):
    def __init__(__self__, *,
                 rke_config: 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfig',
                 cluster_auth_endpoint: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint'] = None,
                 default_cluster_role_for_project_members: Optional[str] = None,
                 default_pod_security_policy_template_id: Optional[str] = None,
                 desired_agent_image: Optional[str] = None,
                 desired_auth_image: Optional[str] = None,
                 docker_root_dir: Optional[str] = None,
                 enable_cluster_alerting: Optional[bool] = None,
                 enable_cluster_monitoring: Optional[bool] = None,
                 enable_network_policy: Optional[bool] = None,
                 scheduled_cluster_scan: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan'] = None,
                 windows_prefered_cluster: Optional[bool] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs' rke_config: Rancher Kubernetes Engine Config (list maxitems: 1)
        :param 'ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs' cluster_auth_endpoint: Local cluster auth endpoint (list maxitems: 1)
        :param str default_cluster_role_for_project_members: Default cluster role for project members (string)
        :param str default_pod_security_policy_template_id: Default pod security policy template ID (string)
        :param str desired_agent_image: Desired agent image (string)
        :param str desired_auth_image: Desired auth image (string)
        :param str docker_root_dir: Desired auth image (string)
        :param bool enable_cluster_alerting: Enable built-in cluster alerting. Default: `false` (bool)
        :param bool enable_cluster_monitoring: Enable built-in cluster monitoring. Default: `false` (bool)
        :param bool enable_network_policy: Enable project network isolation. Default: `false` (bool)
        :param 'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanArgs' scheduled_cluster_scan: Cluster scheduled cis scan. For Rancher v2.4.0 or above (List MaxItem:1)
        :param bool windows_prefered_cluster: Windows prefered cluster. Default: `false` (bool)
        """
        pulumi.set(__self__, "rke_config", rke_config)
        if cluster_auth_endpoint is not None:
            pulumi.set(__self__, "cluster_auth_endpoint", cluster_auth_endpoint)
        if default_cluster_role_for_project_members is not None:
            pulumi.set(__self__, "default_cluster_role_for_project_members", default_cluster_role_for_project_members)
        if default_pod_security_policy_template_id is not None:
            pulumi.set(__self__, "default_pod_security_policy_template_id", default_pod_security_policy_template_id)
        if desired_agent_image is not None:
            pulumi.set(__self__, "desired_agent_image", desired_agent_image)
        if desired_auth_image is not None:
            pulumi.set(__self__, "desired_auth_image", desired_auth_image)
        if docker_root_dir is not None:
            pulumi.set(__self__, "docker_root_dir", docker_root_dir)
        if enable_cluster_alerting is not None:
            pulumi.set(__self__, "enable_cluster_alerting", enable_cluster_alerting)
        if enable_cluster_monitoring is not None:
            pulumi.set(__self__, "enable_cluster_monitoring", enable_cluster_monitoring)
        if enable_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if scheduled_cluster_scan is not None:
            pulumi.set(__self__, "scheduled_cluster_scan", scheduled_cluster_scan)
        if windows_prefered_cluster is not None:
            pulumi.set(__self__, "windows_prefered_cluster", windows_prefered_cluster)

    @property
    @pulumi.getter(name="rkeConfig")
    def rke_config(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfig':
        """
        Rancher Kubernetes Engine Config (list maxitems: 1)
        """
        return pulumi.get(self, "rke_config")

    @property
    @pulumi.getter(name="clusterAuthEndpoint")
    def cluster_auth_endpoint(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint']:
        """
        Local cluster auth endpoint (list maxitems: 1)
        """
        return pulumi.get(self, "cluster_auth_endpoint")

    @property
    @pulumi.getter(name="defaultClusterRoleForProjectMembers")
    def default_cluster_role_for_project_members(self) -> Optional[str]:
        """
        Default cluster role for project members (string)
        """
        return pulumi.get(self, "default_cluster_role_for_project_members")

    @property
    @pulumi.getter(name="defaultPodSecurityPolicyTemplateId")
    def default_pod_security_policy_template_id(self) -> Optional[str]:
        """
        Default pod security policy template ID (string)
        """
        return pulumi.get(self, "default_pod_security_policy_template_id")

    @property
    @pulumi.getter(name="desiredAgentImage")
    def desired_agent_image(self) -> Optional[str]:
        """
        Desired agent image (string)
        """
        return pulumi.get(self, "desired_agent_image")

    @property
    @pulumi.getter(name="desiredAuthImage")
    def desired_auth_image(self) -> Optional[str]:
        """
        Desired auth image (string)
        """
        return pulumi.get(self, "desired_auth_image")

    @property
    @pulumi.getter(name="dockerRootDir")
    def docker_root_dir(self) -> Optional[str]:
        """
        Desired auth image (string)
        """
        return pulumi.get(self, "docker_root_dir")

    @property
    @pulumi.getter(name="enableClusterAlerting")
    def enable_cluster_alerting(self) -> Optional[bool]:
        """
        Enable built-in cluster alerting. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_cluster_alerting")

    @property
    @pulumi.getter(name="enableClusterMonitoring")
    def enable_cluster_monitoring(self) -> Optional[bool]:
        """
        Enable built-in cluster monitoring. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_cluster_monitoring")

    @property
    @pulumi.getter(name="enableNetworkPolicy")
    def enable_network_policy(self) -> Optional[bool]:
        """
        Enable project network isolation. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_network_policy")

    @property
    @pulumi.getter(name="scheduledClusterScan")
    def scheduled_cluster_scan(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan']:
        """
        Cluster scheduled cis scan. For Rancher v2.4.0 or above (List MaxItem:1)
        """
        return pulumi.get(self, "scheduled_cluster_scan")

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[bool]:
        """
        Windows prefered cluster. Default: `false` (bool)
        """
        return pulumi.get(self, "windows_prefered_cluster")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        """
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        """
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfig(dict):
    def __init__(__self__, *,
                 addon_job_timeout: Optional[float] = None,
                 addons: Optional[str] = None,
                 addons_includes: Optional[List[str]] = None,
                 authentication: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthentication'] = None,
                 authorization: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorization'] = None,
                 bastion_host: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost'] = None,
                 cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider'] = None,
                 dns: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns'] = None,
                 ignore_docker_version: Optional[bool] = None,
                 ingress: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress'] = None,
                 kubernetes_version: Optional[str] = None,
                 monitoring: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring'] = None,
                 network: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork'] = None,
                 nodes: Optional[List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode']] = None,
                 prefix_path: Optional[str] = None,
                 private_registries: Optional[List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry']] = None,
                 services: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices'] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_cert_path: Optional[str] = None,
                 ssh_key_path: Optional[str] = None,
                 upgrade_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy'] = None):
        if addon_job_timeout is not None:
            pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if bastion_host is not None:
            pulumi.set(__self__, "bastion_host", bastion_host)
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

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

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

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[List[str]]:
        return pulumi.get(self, "addons_includes")

    @property
    @pulumi.getter
    def authentication(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthentication']:
        return pulumi.get(self, "authentication")

    @property
    @pulumi.getter
    def authorization(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorization']:
        return pulumi.get(self, "authorization")

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost']:
        return pulumi.get(self, "bastion_host")

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider']:
        return pulumi.get(self, "cloud_provider")

    @property
    @pulumi.getter
    def dns(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns']:
        return pulumi.get(self, "dns")

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

    @property
    @pulumi.getter
    def ingress(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress']:
        return pulumi.get(self, "ingress")

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

    @property
    @pulumi.getter
    def monitoring(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring']:
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def network(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork']:
        return pulumi.get(self, "network")

    @property
    @pulumi.getter
    def nodes(self) -> Optional[List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode']]:
        return pulumi.get(self, "nodes")

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

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry']]:
        return pulumi.get(self, "private_registries")

    @property
    @pulumi.getter
    def services(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices']:
        return pulumi.get(self, "services")

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

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

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

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy']:
        return pulumi.get(self, "upgrade_strategy")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthentication(dict):
    def __init__(__self__, *,
                 sans: Optional[List[str]] = None,
                 strategy: Optional[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[List[str]]:
        return pulumi.get(self, "sans")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorization(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None,
                 options: Optional[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[str]:
        return pulumi.get(self, "mode")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost(dict):
    def __init__(__self__, *,
                 address: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[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) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider(dict):
    def __init__(__self__, *,
                 aws_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider'] = None,
                 azure_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider'] = None,
                 custom_cloud_provider: Optional[str] = None,
                 name: Optional[str] = None,
                 openstack_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider'] = None,
                 vsphere_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider'] = None):
        """
        :param str name: The cluster template revision name (string)
        """
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if custom_cloud_provider is not None:
            pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider']:
        return pulumi.get(self, "aws_cloud_provider")

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider']:
        return pulumi.get(self, "azure_cloud_provider")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The cluster template revision name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider']:
        return pulumi.get(self, "openstack_cloud_provider")

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider']:
        return pulumi.get(self, "vsphere_cloud_provider")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider(dict):
    def __init__(__self__, *,
                 global_: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal'] = None,
                 service_overrides: Optional[List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride']] = 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['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal']:
        return pulumi.get(self, "global_")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal(dict):
    def __init__(__self__, *,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None,
                 elb_security_group: Optional[str] = None,
                 kubernetes_cluster_id: Optional[str] = None,
                 kubernetes_cluster_tag: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 route_table_id: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 vpc: Optional[str] = None,
                 zone: Optional[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[bool]:
        return pulumi.get(self, "disable_security_group_ingress")

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride(dict):
    def __init__(__self__, *,
                 service: str,
                 region: Optional[str] = None,
                 signing_method: Optional[str] = None,
                 signing_name: Optional[str] = None,
                 signing_region: Optional[str] = None,
                 url: Optional[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) -> str:
        return pulumi.get(self, "service")

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider(dict):
    def __init__(__self__, *,
                 aad_client_id: str,
                 aad_client_secret: str,
                 subscription_id: str,
                 tenant_id: str,
                 aad_client_cert_password: Optional[str] = None,
                 aad_client_cert_path: Optional[str] = None,
                 cloud: Optional[str] = None,
                 cloud_provider_backoff: Optional[bool] = None,
                 cloud_provider_backoff_duration: Optional[float] = None,
                 cloud_provider_backoff_exponent: Optional[float] = None,
                 cloud_provider_backoff_jitter: Optional[float] = None,
                 cloud_provider_backoff_retries: Optional[float] = None,
                 cloud_provider_rate_limit: Optional[bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[float] = None,
                 cloud_provider_rate_limit_qps: Optional[float] = None,
                 load_balancer_sku: Optional[str] = None,
                 location: Optional[str] = None,
                 maximum_load_balancer_rule_count: Optional[float] = None,
                 primary_availability_set_name: Optional[str] = None,
                 primary_scale_set_name: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 route_table_name: Optional[str] = None,
                 security_group_name: Optional[str] = None,
                 subnet_name: Optional[str] = None,
                 use_instance_metadata: Optional[bool] = None,
                 use_managed_identity_extension: Optional[bool] = None,
                 vm_type: Optional[str] = None,
                 vnet_name: Optional[str] = None,
                 vnet_resource_group: Optional[str] = None):
        pulumi.set(__self__, "aad_client_id", aad_client_id)
        pulumi.set(__self__, "aad_client_secret", aad_client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if aad_client_cert_password is not None:
            pulumi.set(__self__, "aad_client_cert_password", aad_client_cert_password)
        if aad_client_cert_path is not None:
            pulumi.set(__self__, "aad_client_cert_path", aad_client_cert_path)
        if cloud is not None:
            pulumi.set(__self__, "cloud", cloud)
        if cloud_provider_backoff is not None:
            pulumi.set(__self__, "cloud_provider_backoff", cloud_provider_backoff)
        if cloud_provider_backoff_duration is not None:
            pulumi.set(__self__, "cloud_provider_backoff_duration", cloud_provider_backoff_duration)
        if cloud_provider_backoff_exponent is not None:
            pulumi.set(__self__, "cloud_provider_backoff_exponent", cloud_provider_backoff_exponent)
        if cloud_provider_backoff_jitter is not None:
            pulumi.set(__self__, "cloud_provider_backoff_jitter", cloud_provider_backoff_jitter)
        if cloud_provider_backoff_retries is not None:
            pulumi.set(__self__, "cloud_provider_backoff_retries", cloud_provider_backoff_retries)
        if cloud_provider_rate_limit is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit", cloud_provider_rate_limit)
        if cloud_provider_rate_limit_bucket is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_bucket", cloud_provider_rate_limit_bucket)
        if cloud_provider_rate_limit_qps is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_qps", cloud_provider_rate_limit_qps)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if maximum_load_balancer_rule_count is not None:
            pulumi.set(__self__, "maximum_load_balancer_rule_count", maximum_load_balancer_rule_count)
        if primary_availability_set_name is not None:
            pulumi.set(__self__, "primary_availability_set_name", primary_availability_set_name)
        if primary_scale_set_name is not None:
            pulumi.set(__self__, "primary_scale_set_name", primary_scale_set_name)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if route_table_name is not None:
            pulumi.set(__self__, "route_table_name", route_table_name)
        if security_group_name is not None:
            pulumi.set(__self__, "security_group_name", security_group_name)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)
        if use_instance_metadata is not None:
            pulumi.set(__self__, "use_instance_metadata", use_instance_metadata)
        if use_managed_identity_extension is not None:
            pulumi.set(__self__, "use_managed_identity_extension", use_managed_identity_extension)
        if vm_type is not None:
            pulumi.set(__self__, "vm_type", vm_type)
        if vnet_name is not None:
            pulumi.set(__self__, "vnet_name", vnet_name)
        if vnet_resource_group is not None:
            pulumi.set(__self__, "vnet_resource_group", vnet_resource_group)

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

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

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider(dict):
    def __init__(__self__, *,
                 global_: 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal',
                 block_storage: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage'] = None,
                 load_balancer: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer'] = None,
                 metadata: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata'] = None,
                 route: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute'] = 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) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="blockStorage")
    def block_storage(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage']:
        return pulumi.get(self, "block_storage")

    @property
    @pulumi.getter(name="loadBalancer")
    def load_balancer(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer']:
        return pulumi.get(self, "load_balancer")

    @property
    @pulumi.getter
    def metadata(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata']:
        return pulumi.get(self, "metadata")

    @property
    @pulumi.getter
    def route(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute']:
        return pulumi.get(self, "route")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage(dict):
    def __init__(__self__, *,
                 bs_version: Optional[str] = None,
                 ignore_volume_az: Optional[bool] = None,
                 trust_device_path: Optional[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[str]:
        return pulumi.get(self, "bs_version")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal(dict):
    def __init__(__self__, *,
                 auth_url: str,
                 password: str,
                 username: str,
                 ca_file: Optional[str] = None,
                 domain_id: Optional[str] = None,
                 domain_name: Optional[str] = None,
                 region: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 trust_id: Optional[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) -> str:
        return pulumi.get(self, "auth_url")

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer(dict):
    def __init__(__self__, *,
                 create_monitor: Optional[bool] = None,
                 floating_network_id: Optional[str] = None,
                 lb_method: Optional[str] = None,
                 lb_provider: Optional[str] = None,
                 lb_version: Optional[str] = None,
                 manage_security_groups: Optional[bool] = None,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[float] = None,
                 monitor_timeout: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 use_octavia: Optional[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[bool]:
        return pulumi.get(self, "create_monitor")

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata(dict):
    def __init__(__self__, *,
                 request_timeout: Optional[float] = None,
                 search_order: Optional[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[float]:
        return pulumi.get(self, "request_timeout")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute(dict):
    def __init__(__self__, *,
                 router_id: Optional[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[str]:
        return pulumi.get(self, "router_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider(dict):
    def __init__(__self__, *,
                 virtual_centers: List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter'],
                 workspace: 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace',
                 disk: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk'] = None,
                 global_: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal'] = None,
                 network: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork'] = 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) -> List['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter']:
        return pulumi.get(self, "virtual_centers")

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace':
        return pulumi.get(self, "workspace")

    @property
    @pulumi.getter
    def disk(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk']:
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal']:
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter
    def network(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork']:
        return pulumi.get(self, "network")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk(dict):
    def __init__(__self__, *,
                 scsi_controller_type: Optional[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[str]:
        return pulumi.get(self, "scsi_controller_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal(dict):
    def __init__(__self__, *,
                 datacenters: Optional[str] = None,
                 insecure_flag: Optional[bool] = None,
                 password: Optional[str] = None,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[float] = None,
                 user: Optional[str] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if insecure_flag is not None:
            pulumi.set(__self__, "insecure_flag", insecure_flag)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork(dict):
    def __init__(__self__, *,
                 public_network: Optional[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[str]:
        return pulumi.get(self, "public_network")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 user: str,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[float] = None):
        """
        :param str name: The cluster template revision name (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)

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

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template revision name (string)
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace(dict):
    def __init__(__self__, *,
                 datacenter: str,
                 folder: str,
                 server: str,
                 default_datastore: Optional[str] = None,
                 resourcepool_path: Optional[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) -> str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def folder(self) -> str:
        return pulumi.get(self, "folder")

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns(dict):
    def __init__(__self__, *,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 nodelocal: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal'] = None,
                 provider: Optional[str] = None,
                 reverse_cidrs: Optional[List[str]] = None,
                 upstream_nameservers: Optional[List[str]] = None):
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal']:
        return pulumi.get(self, "nodelocal")

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

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[List[str]]:
        return pulumi.get(self, "reverse_cidrs")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal(dict):
    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

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

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress(dict):
    def __init__(__self__, *,
                 dns_policy: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None):
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

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

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring(dict):
    def __init__(__self__, *,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 replicas: Optional[float] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy'] = None):
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

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

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

    @property
    @pulumi.getter
    def replicas(self) -> Optional[float]:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy']:
        return pulumi.get(self, "update_strategy")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate']:
        return pulumi.get(self, "rolling_update")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate(dict):
    def __init__(__self__, *,
                 max_surge: Optional[float] = None,
                 max_unavailable: Optional[float] = None):
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork(dict):
    def __init__(__self__, *,
                 calico_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider'] = None,
                 canal_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider'] = None,
                 flannel_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider'] = None,
                 mtu: Optional[float] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 plugin: Optional[str] = None,
                 weave_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider'] = None):
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider']:
        return pulumi.get(self, "calico_network_provider")

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider']:
        return pulumi.get(self, "canal_network_provider")

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider']:
        return pulumi.get(self, "flannel_network_provider")

    @property
    @pulumi.getter
    def mtu(self) -> Optional[float]:
        return pulumi.get(self, "mtu")

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

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

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider']:
        return pulumi.get(self, "weave_network_provider")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider(dict):
    def __init__(__self__, *,
                 cloud_provider: Optional[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[str]:
        return pulumi.get(self, "cloud_provider")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[str] = None):
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[str] = None):
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider(dict):
    def __init__(__self__, *,
                 password: str):
        pulumi.set(__self__, "password", password)

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode(dict):
    def __init__(__self__, *,
                 address: str,
                 roles: List[str],
                 user: str,
                 docker_socket: Optional[str] = None,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[str] = None):
        """
        :param Mapping[str, Any] labels: Labels for the cluster template revision (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

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

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

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        Labels for the cluster template revision (map)
        """
        return pulumi.get(self, "labels")

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry(dict):
    def __init__(__self__, *,
                 url: str,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices(dict):
    def __init__(__self__, *,
                 etcd: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd'] = None,
                 kube_api: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi'] = None,
                 kube_controller: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController'] = None,
                 kubelet: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet'] = None,
                 kubeproxy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy'] = None,
                 scheduler: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler'] = 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['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd']:
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi']:
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController']:
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet']:
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy']:
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler']:
        return pulumi.get(self, "scheduler")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd(dict):
    def __init__(__self__, *,
                 backup_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig'] = None,
                 ca_cert: Optional[str] = None,
                 cert: Optional[str] = None,
                 creation: Optional[str] = None,
                 external_urls: Optional[List[str]] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 gid: Optional[float] = None,
                 image: Optional[str] = None,
                 key: Optional[str] = None,
                 path: Optional[str] = None,
                 retention: Optional[str] = None,
                 snapshot: Optional[bool] = None,
                 uid: Optional[float] = None):
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig']:
        return pulumi.get(self, "backup_config")

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

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

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

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[List[str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def snapshot(self) -> Optional[bool]:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter
    def uid(self) -> Optional[float]:
        return pulumi.get(self, "uid")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[float] = None,
                 retention: Optional[float] = None,
                 s3_backup_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None):
        """
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

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

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

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig']:
        return pulumi.get(self, "s3_backup_config")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[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) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi(dict):
    def __init__(__self__, *,
                 admission_configuration: Optional[Mapping[str, Any]] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog'] = None,
                 event_rate_limit: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit'] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[str] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig'] = None,
                 service_cluster_ip_range: Optional[str] = None,
                 service_node_port_range: Optional[str] = None):
        if admission_configuration is not None:
            pulumi.set(__self__, "admission_configuration", admission_configuration)
        if always_pull_images is not None:
            pulumi.set(__self__, "always_pull_images", always_pull_images)
        if audit_log is not None:
            pulumi.set(__self__, "audit_log", audit_log)
        if event_rate_limit is not None:
            pulumi.set(__self__, "event_rate_limit", event_rate_limit)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if service_node_port_range is not None:
            pulumi.set(__self__, "service_node_port_range", service_node_port_range)

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "admission_configuration")

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

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit']:
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

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

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

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

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig']:
        return pulumi.get(self, "secrets_encryption_config")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog(dict):
    def __init__(__self__, *,
                 configuration: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration'] = None,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration']:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration(dict):
    def __init__(__self__, *,
                 format: Optional[str] = None,
                 max_age: Optional[float] = None,
                 max_backup: Optional[float] = None,
                 max_size: Optional[float] = None,
                 path: Optional[str] = None,
                 policy: Optional[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[str]:
        return pulumi.get(self, "format")

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit(dict):
    def __init__(__self__, *,
                 configuration: Optional[str] = None,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig(dict):
    def __init__(__self__, *,
                 custom_config: Optional[str] = None,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        """
        if custom_config is not None:
            pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController(dict):
    def __init__(__self__, *,
                 cluster_cidr: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[str] = None,
                 service_cluster_ip_range: Optional[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[str]:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet(dict):
    def __init__(__self__, *,
                 cluster_dns_server: Optional[str] = None,
                 cluster_domain: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 fail_swap_on: Optional[bool] = None,
                 generate_serving_certificate: Optional[bool] = None,
                 image: Optional[str] = None,
                 infra_container_image: Optional[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[str]:
        return pulumi.get(self, "cluster_dns_server")

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

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy(dict):
    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[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[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler(dict):
    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 image: Optional[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[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy(dict):
    def __init__(__self__, *,
                 drain: Optional[bool] = None,
                 drain_input: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput'] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[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[bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput']:
        return pulumi.get(self, "drain_input")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[float] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[float] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        return pulumi.get(self, "force")

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan(dict):
    def __init__(__self__, *,
                 scan_config: 'outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig',
                 schedule_config: 'outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig',
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Enable cluster template revision. Default `true` (bool)
        """
        pulumi.set(__self__, "scan_config", scan_config)
        pulumi.set(__self__, "schedule_config", schedule_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="scanConfig")
    def scan_config(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig':
        return pulumi.get(self, "scan_config")

    @property
    @pulumi.getter(name="scheduleConfig")
    def schedule_config(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig':
        return pulumi.get(self, "schedule_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig(dict):
    def __init__(__self__, *,
                 cis_scan_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig'] = None):
        if cis_scan_config is not None:
            pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig']:
        return pulumi.get(self, "cis_scan_config")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig(dict):
    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[List[str]] = None,
                 profile: Optional[str] = None):
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

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

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

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

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[List[str]]:
        return pulumi.get(self, "override_skips")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig(dict):
    def __init__(__self__, *,
                 cron_schedule: str,
                 retention: Optional[float] = None):
        pulumi.set(__self__, "cron_schedule", cron_schedule)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)

    @property
    @pulumi.getter(name="cronSchedule")
    def cron_schedule(self) -> str:
        return pulumi.get(self, "cron_schedule")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class EtcdBackupBackupConfig(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[float] = None,
                 retention: Optional[float] = None,
                 s3_backup_config: Optional['outputs.EtcdBackupBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None):
        """
        :param bool enabled: Enable etcd backup (bool)
        :param float interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param float retention: Retention for etcd backup. Default `6` (int)
        :param 'EtcdBackupBackupConfigS3BackupConfigArgs' s3_backup_config: S3 config options for etcd backup. Valid for `imported` and `rke` clusters. (list maxitems:1)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable etcd backup (bool)
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[float]:
        """
        Interval hours for etcd backup. Default `12` (int)
        """
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[float]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.EtcdBackupBackupConfigS3BackupConfig']:
        """
        S3 config options for etcd backup. Valid for `imported` and `rke` clusters. (list maxitems:1)
        """
        return pulumi.get(self, "s3_backup_config")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class EtcdBackupBackupConfigS3BackupConfig(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        """
        :param str bucket_name: Bucket name for S3 service (string)
        :param str endpoint: Endpoint for S3 service (string)
        :param str access_key: Access key for S3 service (string)
        :param str custom_ca: Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        :param str folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param str region: Region for S3 service (string)
        :param str secret_key: Secret key for S3 service (string)
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        """
        Bucket name for S3 service (string)
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        Endpoint for S3 service (string)
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        """
        Access key for S3 service (string)
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        """
        Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        """
        return pulumi.get(self, "custom_ca")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Region for S3 service (string)
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        """
        Secret key for S3 service (string)
        """
        return pulumi.get(self, "secret_key")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class MultiClusterAppMember(dict):
    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        """
        :param str access_type: Member access type. Valid values: `["member" | "owner" | "read-only"]` (string)
        :param str group_principal_id: Member group principal id (string)
        :param str user_principal_id: Member user principal id (string)
        """
        if access_type is not None:
            pulumi.set(__self__, "access_type", access_type)
        if group_principal_id is not None:
            pulumi.set(__self__, "group_principal_id", group_principal_id)
        if user_principal_id is not None:
            pulumi.set(__self__, "user_principal_id", user_principal_id)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> Optional[str]:
        """
        Member access type. Valid values: `["member" | "owner" | "read-only"]` (string)
        """
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[str]:
        """
        Member group principal id (string)
        """
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        """
        Member user principal id (string)
        """
        return pulumi.get(self, "user_principal_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class MultiClusterAppTarget(dict):
    def __init__(__self__, *,
                 project_id: str,
                 app_id: Optional[str] = None,
                 health_state: Optional[str] = None,
                 state: Optional[str] = None):
        """
        :param str project_id: Project ID for target (string)
        :param str app_id: App ID for target (string)
        :param str health_state: App health state for target (string)
        :param str state: App state for target (string)
        """
        pulumi.set(__self__, "project_id", project_id)
        if app_id is not None:
            pulumi.set(__self__, "app_id", app_id)
        if health_state is not None:
            pulumi.set(__self__, "health_state", health_state)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        Project ID for target (string)
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> Optional[str]:
        """
        App ID for target (string)
        """
        return pulumi.get(self, "app_id")

    @property
    @pulumi.getter(name="healthState")
    def health_state(self) -> Optional[str]:
        """
        App health state for target (string)
        """
        return pulumi.get(self, "health_state")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        App state for target (string)
        """
        return pulumi.get(self, "state")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class MultiClusterAppUpgradeStrategy(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.MultiClusterAppUpgradeStrategyRollingUpdate'] = None):
        """
        :param 'MultiClusterAppUpgradeStrategyRollingUpdateArgs' rolling_update: Upgrade strategy rolling update (list MaxItems:1)
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.MultiClusterAppUpgradeStrategyRollingUpdate']:
        """
        Upgrade strategy rolling update (list MaxItems:1)
        """
        return pulumi.get(self, "rolling_update")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class MultiClusterAppUpgradeStrategyRollingUpdate(dict):
    def __init__(__self__, *,
                 batch_size: Optional[float] = None,
                 interval: Optional[float] = None):
        """
        :param float batch_size: Rolling update batch size. Default `1` (int)
        :param float interval: Rolling update interval. Default `1` (int)
        """
        if batch_size is not None:
            pulumi.set(__self__, "batch_size", batch_size)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)

    @property
    @pulumi.getter(name="batchSize")
    def batch_size(self) -> Optional[float]:
        """
        Rolling update batch size. Default `1` (int)
        """
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def interval(self) -> Optional[float]:
        """
        Rolling update interval. Default `1` (int)
        """
        return pulumi.get(self, "interval")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NamespaceContainerResourceLimit(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None):
        """
        :param str limits_cpu: Limit for limits cpu in namespace (string)
        :param str limits_memory: Limit for limits memory in namespace (string)
        :param str requests_cpu: Limit for requests cpu in namespace (string)
        :param str requests_memory: Limit for requests memory in namespace (string)
        """
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        """
        Limit for limits cpu in namespace (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        """
        Limit for limits memory in namespace (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        """
        Limit for requests cpu in namespace (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        """
        Limit for requests memory in namespace (string)
        """
        return pulumi.get(self, "requests_memory")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NamespaceResourceQuota(dict):
    def __init__(__self__, *,
                 limit: 'outputs.NamespaceResourceQuotaLimit'):
        """
        :param 'NamespaceResourceQuotaLimitArgs' limit: Resource quota limit for namespace (list maxitems:1)
        """
        pulumi.set(__self__, "limit", limit)

    @property
    @pulumi.getter
    def limit(self) -> 'outputs.NamespaceResourceQuotaLimit':
        """
        Resource quota limit for namespace (list maxitems:1)
        """
        return pulumi.get(self, "limit")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NamespaceResourceQuotaLimit(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        """
        :param str config_maps: Limit for config maps in namespace (string)
        :param str limits_cpu: Limit for limits cpu in namespace (string)
        :param str limits_memory: Limit for limits memory in namespace (string)
        :param str persistent_volume_claims: Limit for persistent volume claims in namespace (string)
        :param str pods: Limit for pods in namespace (string)
        :param str replication_controllers: Limit for replication controllers in namespace (string)
        :param str requests_cpu: Limit for requests cpu in namespace (string)
        :param str requests_memory: Limit for requests memory in namespace (string)
        :param str requests_storage: Limit for requests storage in namespace (string)
        :param str secrets: Limit for secrets in namespace (string)
        :param str services_load_balancers: Limit for services load balancers in namespace (string)
        :param str services_node_ports: Limit for services node ports in namespace (string)
        """
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        """
        Limit for config maps in namespace (string)
        """
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        """
        Limit for limits cpu in namespace (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        """
        Limit for limits memory in namespace (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        """
        Limit for persistent volume claims in namespace (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        """
        Limit for pods in namespace (string)
        """
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        """
        Limit for replication controllers in namespace (string)
        """
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        """
        Limit for requests cpu in namespace (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        """
        Limit for requests memory in namespace (string)
        """
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        """
        Limit for requests storage in namespace (string)
        """
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        """
        Limit for secrets in namespace (string)
        """
        return pulumi.get(self, "secrets")

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

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        """
        Limit for services load balancers in namespace (string)
        """
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        """
        Limit for services node ports in namespace (string)
        """
        return pulumi.get(self, "services_node_ports")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodePoolNodeTaint(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 effect: Optional[str] = None,
                 time_added: Optional[str] = None):
        """
        :param str key: Taint key (string)
        :param str value: Taint value (string)
        :param str effect: Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        :param str time_added: Taint time added (string)
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if time_added is not None:
            pulumi.set(__self__, "time_added", time_added)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Taint key (string)
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Taint value (string)
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        """
        Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> Optional[str]:
        """
        Taint time added (string)
        """
        return pulumi.get(self, "time_added")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateAmazonec2Config(dict):
    def __init__(__self__, *,
                 ami: str,
                 region: str,
                 security_groups: List[str],
                 subnet_id: str,
                 vpc_id: str,
                 zone: str,
                 access_key: Optional[str] = None,
                 block_duration_minutes: Optional[str] = None,
                 device_name: Optional[str] = None,
                 encrypt_ebs_volume: Optional[bool] = None,
                 endpoint: Optional[str] = None,
                 iam_instance_profile: Optional[str] = None,
                 insecure_transport: Optional[bool] = None,
                 instance_type: Optional[str] = None,
                 keypair_name: Optional[str] = None,
                 kms_key: Optional[str] = None,
                 monitoring: Optional[bool] = None,
                 open_ports: Optional[List[str]] = None,
                 private_address_only: Optional[bool] = None,
                 request_spot_instance: Optional[bool] = None,
                 retries: Optional[str] = None,
                 root_size: Optional[str] = None,
                 secret_key: Optional[str] = None,
                 security_group_readonly: Optional[bool] = None,
                 session_token: Optional[str] = None,
                 spot_price: Optional[str] = None,
                 ssh_keypath: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tags: Optional[str] = None,
                 use_ebs_optimized_instance: Optional[bool] = None,
                 use_private_address: Optional[bool] = None,
                 userdata: Optional[str] = None,
                 volume_type: Optional[str] = None):
        """
        :param str ami: AWS machine image (string)
        :param str region: OpenStack region name (string)
        :param List[str] security_groups: AWS VPC security group. (list)
        :param str subnet_id: AWS VPC subnet id (string)
        :param str vpc_id: AWS VPC id. (string)
        :param str zone: AWS zone for instance (i.e. a,b,c,d,e) (string)
        :param str access_key: AWS access key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360). Default `0` (string)
        :param str device_name: AWS root device name. Default `/dev/sda1` (string)
        :param bool encrypt_ebs_volume: Encrypt EBS volume. Default `false` (bool)
        :param str endpoint: Optional endpoint URL (hostname only or fully qualified URI) (string)
        :param str iam_instance_profile: AWS IAM Instance Profile (string)
        :param bool insecure_transport: Disable SSL when sending requests (bool)
        :param str instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        :param str keypair_name: OpenStack keypair to use to SSH to the instance (string)
        :param str kms_key: Custom KMS key ID using the AWS Managed CMK (string)
        :param bool monitoring: Enable monitoring for droplet. Default `false` (bool)
        :param List[str] open_ports: Make the specified port number accessible from the Internet. (list)
        :param bool private_address_only: Only use a private IP address. Default `false` (bool)
        :param bool request_spot_instance: Set this flag to request spot instance. Default `false` (bool)
        :param str retries: Set retry count for recoverable failures (use -1 to disable). Default `5` (string)
        :param str root_size: AWS root disk size (in GB). Default `16` (string)
        :param str secret_key: AWS secret key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param bool security_group_readonly: Skip adding default rules to security groups (bool)
        :param str session_token: AWS Session Token (string)
        :param str spot_price: AWS spot instance bid price (in dollar). Default `0.50` (string)
        :param str ssh_keypath: SSH Key for Instance (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param str tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param bool use_ebs_optimized_instance: Create an EBS optimized instance. Default `false` (bool)
        :param bool use_private_address: Force the usage of private IP address. Default `false` (bool)
        :param str userdata: Path to file with cloud-init user-data (string)
        :param str volume_type: Amazon EBS volume type. Default `gp2` (string)
        """
        pulumi.set(__self__, "ami", ami)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "security_groups", security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "zone", zone)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if encrypt_ebs_volume is not None:
            pulumi.set(__self__, "encrypt_ebs_volume", encrypt_ebs_volume)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if insecure_transport is not None:
            pulumi.set(__self__, "insecure_transport", insecure_transport)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_address_only is not None:
            pulumi.set(__self__, "private_address_only", private_address_only)
        if request_spot_instance is not None:
            pulumi.set(__self__, "request_spot_instance", request_spot_instance)
        if retries is not None:
            pulumi.set(__self__, "retries", retries)
        if root_size is not None:
            pulumi.set(__self__, "root_size", root_size)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)
        if security_group_readonly is not None:
            pulumi.set(__self__, "security_group_readonly", security_group_readonly)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if ssh_keypath is not None:
            pulumi.set(__self__, "ssh_keypath", ssh_keypath)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if use_ebs_optimized_instance is not None:
            pulumi.set(__self__, "use_ebs_optimized_instance", use_ebs_optimized_instance)
        if use_private_address is not None:
            pulumi.set(__self__, "use_private_address", use_private_address)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def ami(self) -> str:
        """
        AWS machine image (string)
        """
        return pulumi.get(self, "ami")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> List[str]:
        """
        AWS VPC security group. (list)
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        AWS VPC subnet id (string)
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        AWS VPC id. (string)
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter
    def zone(self) -> str:
        """
        AWS zone for instance (i.e. a,b,c,d,e) (string)
        """
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        """
        AWS access key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[str]:
        """
        AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360). Default `0` (string)
        """
        return pulumi.get(self, "block_duration_minutes")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[str]:
        """
        AWS root device name. Default `/dev/sda1` (string)
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="encryptEbsVolume")
    def encrypt_ebs_volume(self) -> Optional[bool]:
        """
        Encrypt EBS volume. Default `false` (bool)
        """
        return pulumi.get(self, "encrypt_ebs_volume")

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[str]:
        """
        Optional endpoint URL (hostname only or fully qualified URI) (string)
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional[str]:
        """
        AWS IAM Instance Profile (string)
        """
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="insecureTransport")
    def insecure_transport(self) -> Optional[bool]:
        """
        Disable SSL when sending requests (bool)
        """
        return pulumi.get(self, "insecure_transport")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="keypairName")
    def keypair_name(self) -> Optional[str]:
        """
        OpenStack keypair to use to SSH to the instance (string)
        """
        return pulumi.get(self, "keypair_name")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[str]:
        """
        Custom KMS key ID using the AWS Managed CMK (string)
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[bool]:
        """
        Enable monitoring for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[List[str]]:
        """
        Make the specified port number accessible from the Internet. (list)
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[bool]:
        """
        Only use a private IP address. Default `false` (bool)
        """
        return pulumi.get(self, "private_address_only")

    @property
    @pulumi.getter(name="requestSpotInstance")
    def request_spot_instance(self) -> Optional[bool]:
        """
        Set this flag to request spot instance. Default `false` (bool)
        """
        return pulumi.get(self, "request_spot_instance")

    @property
    @pulumi.getter
    def retries(self) -> Optional[str]:
        """
        Set retry count for recoverable failures (use -1 to disable). Default `5` (string)
        """
        return pulumi.get(self, "retries")

    @property
    @pulumi.getter(name="rootSize")
    def root_size(self) -> Optional[str]:
        """
        AWS root disk size (in GB). Default `16` (string)
        """
        return pulumi.get(self, "root_size")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        """
        AWS secret key. Required on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="securityGroupReadonly")
    def security_group_readonly(self) -> Optional[bool]:
        """
        Skip adding default rules to security groups (bool)
        """
        return pulumi.get(self, "security_group_readonly")

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[str]:
        """
        AWS Session Token (string)
        """
        return pulumi.get(self, "session_token")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[str]:
        """
        AWS spot instance bid price (in dollar). Default `0.50` (string)
        """
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="sshKeypath")
    def ssh_keypath(self) -> Optional[str]:
        """
        SSH Key for Instance (string)
        """
        return pulumi.get(self, "ssh_keypath")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="useEbsOptimizedInstance")
    def use_ebs_optimized_instance(self) -> Optional[bool]:
        """
        Create an EBS optimized instance. Default `false` (bool)
        """
        return pulumi.get(self, "use_ebs_optimized_instance")

    @property
    @pulumi.getter(name="usePrivateAddress")
    def use_private_address(self) -> Optional[bool]:
        """
        Force the usage of private IP address. Default `false` (bool)
        """
        return pulumi.get(self, "use_private_address")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[str]:
        """
        Path to file with cloud-init user-data (string)
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        """
        Amazon EBS volume type. Default `gp2` (string)
        """
        return pulumi.get(self, "volume_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateAzureConfig(dict):
    def __init__(__self__, *,
                 availability_set: Optional[str] = None,
                 client_id: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 custom_data: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 dns: Optional[str] = None,
                 docker_port: Optional[str] = None,
                 environment: Optional[str] = None,
                 fault_domain_count: Optional[str] = None,
                 image: Optional[str] = None,
                 location: Optional[str] = None,
                 managed_disks: Optional[bool] = None,
                 no_public_ip: Optional[bool] = None,
                 nsg: Optional[str] = None,
                 open_ports: Optional[List[str]] = None,
                 private_ip_address: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 size: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 static_public_ip: Optional[bool] = None,
                 storage_type: Optional[str] = None,
                 subnet: Optional[str] = None,
                 subnet_prefix: Optional[str] = None,
                 subscription_id: Optional[str] = None,
                 update_domain_count: Optional[str] = None,
                 use_private_ip: Optional[bool] = None,
                 vnet: Optional[str] = None):
        """
        :param str availability_set: Azure Availability Set to place the virtual machine into. Default `docker-machine` (string)
        :param str client_id: Azure Service Principal Account ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str client_secret: Azure Service Principal Account password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str custom_data: Path to file with custom-data (string)
        :param str disk_size: vSphere size of disk for docker VM (in MB). Default `20480` (string)
        :param str dns: A unique DNS label for the public IP adddress (string)
        :param str docker_port: Docker Port. Default `2376` (string)
        :param str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud). Default `AzurePublicCloud` (string)
        :param str fault_domain_count: Fault domain count to use for availability set. Default `3` (string)
        :param str image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param str location: Azure region to create the virtual machine. Default `westus` (string)
        :param bool managed_disks: Configures VM and availability set for managed disks. Just for Rancher v2.3.x and above. Default `false` (bool)
        :param bool no_public_ip: Do not create a public IP address for the machine. Default `false` (bool)
        :param str nsg: Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine). Default `docker-machine-nsg` (string)
        :param List[str] open_ports: Make the specified port number accessible from the Internet. (list)
        :param str private_ip_address: Specify a static private IP address for the machine. (string)
        :param str resource_group: Azure Resource Group name (will be created if missing). Default `docker-machine` (string)
        :param str size: Digital Ocean size. Default `s-1vcpu-1gb` (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param bool static_public_ip: Assign a static public IP address to the machine. Default `false` (bool)
        :param str storage_type: Type of Storage Account to host the OS Disk for the machine. Default `Standard_LRS` (string)
        :param str subnet: Azure Subnet Name to be used within the Virtual Network. Default `docker-machine` (string)
        :param str subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918. Default `192.168.0.0/16` (string)
        :param str subscription_id: Azure Subscription ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str update_domain_count: Update domain count to use for availability set. Default `5` (string)
        :param bool use_private_ip: Use private IP address of the machine to connect. Default `false` (bool)
        :param str vnet: Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format). Default `docker-machine-vnet` (string)
        """
        if availability_set is not None:
            pulumi.set(__self__, "availability_set", availability_set)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if custom_data is not None:
            pulumi.set(__self__, "custom_data", custom_data)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if fault_domain_count is not None:
            pulumi.set(__self__, "fault_domain_count", fault_domain_count)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if managed_disks is not None:
            pulumi.set(__self__, "managed_disks", managed_disks)
        if no_public_ip is not None:
            pulumi.set(__self__, "no_public_ip", no_public_ip)
        if nsg is not None:
            pulumi.set(__self__, "nsg", nsg)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if static_public_ip is not None:
            pulumi.set(__self__, "static_public_ip", static_public_ip)
        if storage_type is not None:
            pulumi.set(__self__, "storage_type", storage_type)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if subnet_prefix is not None:
            pulumi.set(__self__, "subnet_prefix", subnet_prefix)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if update_domain_count is not None:
            pulumi.set(__self__, "update_domain_count", update_domain_count)
        if use_private_ip is not None:
            pulumi.set(__self__, "use_private_ip", use_private_ip)
        if vnet is not None:
            pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="availabilitySet")
    def availability_set(self) -> Optional[str]:
        """
        Azure Availability Set to place the virtual machine into. Default `docker-machine` (string)
        """
        return pulumi.get(self, "availability_set")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        Azure Service Principal Account ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[str]:
        """
        Azure Service Principal Account password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="customData")
    def custom_data(self) -> Optional[str]:
        """
        Path to file with custom-data (string)
        """
        return pulumi.get(self, "custom_data")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[str]:
        """
        vSphere size of disk for docker VM (in MB). Default `20480` (string)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def dns(self) -> Optional[str]:
        """
        A unique DNS label for the public IP adddress (string)
        """
        return pulumi.get(self, "dns")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[str]:
        """
        Docker Port. Default `2376` (string)
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def environment(self) -> Optional[str]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud). Default `AzurePublicCloud` (string)
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="faultDomainCount")
    def fault_domain_count(self) -> Optional[str]:
        """
        Fault domain count to use for availability set. Default `3` (string)
        """
        return pulumi.get(self, "fault_domain_count")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def location(self) -> Optional[str]:
        """
        Azure region to create the virtual machine. Default `westus` (string)
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="managedDisks")
    def managed_disks(self) -> Optional[bool]:
        """
        Configures VM and availability set for managed disks. Just for Rancher v2.3.x and above. Default `false` (bool)
        """
        return pulumi.get(self, "managed_disks")

    @property
    @pulumi.getter(name="noPublicIp")
    def no_public_ip(self) -> Optional[bool]:
        """
        Do not create a public IP address for the machine. Default `false` (bool)
        """
        return pulumi.get(self, "no_public_ip")

    @property
    @pulumi.getter
    def nsg(self) -> Optional[str]:
        """
        Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine). Default `docker-machine-nsg` (string)
        """
        return pulumi.get(self, "nsg")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[List[str]]:
        """
        Make the specified port number accessible from the Internet. (list)
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        """
        Specify a static private IP address for the machine. (string)
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[str]:
        """
        Azure Resource Group name (will be created if missing). Default `docker-machine` (string)
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Digital Ocean size. Default `s-1vcpu-1gb` (string)
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="staticPublicIp")
    def static_public_ip(self) -> Optional[bool]:
        """
        Assign a static public IP address to the machine. Default `false` (bool)
        """
        return pulumi.get(self, "static_public_ip")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[str]:
        """
        Type of Storage Account to host the OS Disk for the machine. Default `Standard_LRS` (string)
        """
        return pulumi.get(self, "storage_type")

    @property
    @pulumi.getter
    def subnet(self) -> Optional[str]:
        """
        Azure Subnet Name to be used within the Virtual Network. Default `docker-machine` (string)
        """
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter(name="subnetPrefix")
    def subnet_prefix(self) -> Optional[str]:
        """
        Private CIDR block to be used for the new subnet, should comply RFC 1918. Default `192.168.0.0/16` (string)
        """
        return pulumi.get(self, "subnet_prefix")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[str]:
        """
        Azure Subscription ID. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="updateDomainCount")
    def update_domain_count(self) -> Optional[str]:
        """
        Update domain count to use for availability set. Default `5` (string)
        """
        return pulumi.get(self, "update_domain_count")

    @property
    @pulumi.getter(name="usePrivateIp")
    def use_private_ip(self) -> Optional[bool]:
        """
        Use private IP address of the machine to connect. Default `false` (bool)
        """
        return pulumi.get(self, "use_private_ip")

    @property
    @pulumi.getter
    def vnet(self) -> Optional[str]:
        """
        Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format). Default `docker-machine-vnet` (string)
        """
        return pulumi.get(self, "vnet")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateDigitaloceanConfig(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 backups: Optional[bool] = None,
                 image: Optional[str] = None,
                 ipv6: Optional[bool] = None,
                 monitoring: Optional[bool] = None,
                 private_networking: Optional[bool] = None,
                 region: Optional[str] = None,
                 size: Optional[str] = None,
                 ssh_key_fingerprint: Optional[str] = None,
                 ssh_key_path: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tags: Optional[str] = None,
                 userdata: Optional[str] = None):
        """
        :param str access_token: Digital Ocean access token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param bool backups: Enable backups for droplet. Default `false` (bool)
        :param str image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param bool ipv6: Enable ipv6 for droplet. Default `false` (bool)
        :param bool monitoring: Enable monitoring for droplet. Default `false` (bool)
        :param bool private_networking: Enable private networking for droplet. Default `false` (bool)
        :param str region: OpenStack region name (string)
        :param str size: Digital Ocean size. Default `s-1vcpu-1gb` (string)
        :param str ssh_key_fingerprint: SSH key fingerprint (string)
        :param str ssh_key_path: SSH private key path (string)
        :param str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param str tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param str userdata: Path to file with cloud-init user-data (string)
        """
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if backups is not None:
            pulumi.set(__self__, "backups", backups)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if private_networking is not None:
            pulumi.set(__self__, "private_networking", private_networking)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_key_fingerprint is not None:
            pulumi.set(__self__, "ssh_key_fingerprint", ssh_key_fingerprint)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[str]:
        """
        Digital Ocean access token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter
    def backups(self) -> Optional[bool]:
        """
        Enable backups for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "backups")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[bool]:
        """
        Enable ipv6 for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "ipv6")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[bool]:
        """
        Enable monitoring for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="privateNetworking")
    def private_networking(self) -> Optional[bool]:
        """
        Enable private networking for droplet. Default `false` (bool)
        """
        return pulumi.get(self, "private_networking")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Digital Ocean size. Default `s-1vcpu-1gb` (string)
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[str]:
        """
        SSH key fingerprint (string)
        """
        return pulumi.get(self, "ssh_key_fingerprint")

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

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[str]:
        """
        Path to file with cloud-init user-data (string)
        """
        return pulumi.get(self, "userdata")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateLinodeConfig(dict):
    def __init__(__self__, *,
                 authorized_users: Optional[str] = None,
                 create_private_ip: Optional[bool] = None,
                 docker_port: Optional[str] = None,
                 image: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 label: Optional[str] = None,
                 region: Optional[str] = None,
                 root_pass: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 stackscript: Optional[str] = None,
                 stackscript_data: Optional[str] = None,
                 swap_size: Optional[str] = None,
                 tags: Optional[str] = None,
                 token: Optional[str] = None,
                 ua_prefix: Optional[str] = None):
        """
        :param str authorized_users: Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node. (string)
        :param bool create_private_ip: Create private IP for the instance. Default `false` (bool)
        :param str docker_port: Docker Port. Default `2376` (string)
        :param str image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param str instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        :param str label: Linode Instance Label. (string)
        :param str region: OpenStack region name (string)
        :param str root_pass: Root Password (string)
        :param str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param str stackscript: Specifies the Linode StackScript to use to create the instance. (string)
        :param str stackscript_data: A JSON string specifying data for the selected StackScript. (string)
        :param str swap_size: Linode Instance Swap Size (MB). Default `512` (string)
        :param str tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param str token: Linode API token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str ua_prefix: Prefix the User-Agent in Linode API calls with some 'product/version' (string)
        """
        if authorized_users is not None:
            pulumi.set(__self__, "authorized_users", authorized_users)
        if create_private_ip is not None:
            pulumi.set(__self__, "create_private_ip", create_private_ip)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if root_pass is not None:
            pulumi.set(__self__, "root_pass", root_pass)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if stackscript is not None:
            pulumi.set(__self__, "stackscript", stackscript)
        if stackscript_data is not None:
            pulumi.set(__self__, "stackscript_data", stackscript_data)
        if swap_size is not None:
            pulumi.set(__self__, "swap_size", swap_size)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if ua_prefix is not None:
            pulumi.set(__self__, "ua_prefix", ua_prefix)

    @property
    @pulumi.getter(name="authorizedUsers")
    def authorized_users(self) -> Optional[str]:
        """
        Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node. (string)
        """
        return pulumi.get(self, "authorized_users")

    @property
    @pulumi.getter(name="createPrivateIp")
    def create_private_ip(self) -> Optional[bool]:
        """
        Create private IP for the instance. Default `false` (bool)
        """
        return pulumi.get(self, "create_private_ip")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[str]:
        """
        Docker Port. Default `2376` (string)
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc. Default `g6-standard-4` (string)
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Linode Instance Label. (string)
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="rootPass")
    def root_pass(self) -> Optional[str]:
        """
        Root Password (string)
        """
        return pulumi.get(self, "root_pass")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def stackscript(self) -> Optional[str]:
        """
        Specifies the Linode StackScript to use to create the instance. (string)
        """
        return pulumi.get(self, "stackscript")

    @property
    @pulumi.getter(name="stackscriptData")
    def stackscript_data(self) -> Optional[str]:
        """
        A JSON string specifying data for the selected StackScript. (string)
        """
        return pulumi.get(self, "stackscript_data")

    @property
    @pulumi.getter(name="swapSize")
    def swap_size(self) -> Optional[str]:
        """
        Linode Instance Swap Size (MB). Default `512` (string)
        """
        return pulumi.get(self, "swap_size")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def token(self) -> Optional[str]:
        """
        Linode API token. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="uaPrefix")
    def ua_prefix(self) -> Optional[str]:
        """
        Prefix the User-Agent in Linode API calls with some 'product/version' (string)
        """
        return pulumi.get(self, "ua_prefix")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateOpennebulaConfig(dict):
    def __init__(__self__, *,
                 password: str,
                 user: str,
                 xml_rpc_url: str,
                 b2d_size: Optional[str] = None,
                 cpu: Optional[str] = None,
                 dev_prefix: Optional[str] = None,
                 disable_vnc: Optional[bool] = None,
                 disk_resize: Optional[str] = None,
                 image_id: Optional[str] = None,
                 image_name: Optional[str] = None,
                 image_owner: Optional[str] = None,
                 memory: Optional[str] = None,
                 network_id: Optional[str] = None,
                 network_name: Optional[str] = None,
                 network_owner: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 template_id: Optional[str] = None,
                 template_name: Optional[str] = None,
                 vcpu: Optional[str] = None):
        """
        :param str password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str user: Set the user for the XML-RPC API authentication (string)
        :param str xml_rpc_url: Set the url for the Opennebula XML-RPC API (string)
        :param str b2d_size: Size of the Volatile disk in MB - only for b2d (string)
        :param str cpu: CPU value for the VM (string)
        :param str dev_prefix: Dev prefix to use for the images. E.g.: 'vd', 'sd', 'hd' (string)
        :param bool disable_vnc: VNC is enabled by default. Disable it with this flag (bool)
        :param str disk_resize: Size of the disk for the VM in MB (string)
        :param str image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param str image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param str image_owner: Owner of the image to use as the VM OS (string)
        :param str memory: Size of the memory for the VM in MB (string)
        :param str network_id: Opennebula network ID to connect the machine to. Conflicts with `network_name` (string)
        :param str network_name: Opennebula network to connect the machine to. Conflicts with `network_id` (string)
        :param str network_owner: Opennebula user ID of the Network to connect the machine to (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param str template_id: Opennebula template ID to use. Conflicts with `template_name` (string)
        :param str template_name: Name of the Opennbula template to use. Conflicts with `template_id` (string)
        :param str vcpu: VCPUs for the VM (string)
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        pulumi.set(__self__, "xml_rpc_url", xml_rpc_url)
        if b2d_size is not None:
            pulumi.set(__self__, "b2d_size", b2d_size)
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if dev_prefix is not None:
            pulumi.set(__self__, "dev_prefix", dev_prefix)
        if disable_vnc is not None:
            pulumi.set(__self__, "disable_vnc", disable_vnc)
        if disk_resize is not None:
            pulumi.set(__self__, "disk_resize", disk_resize)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if image_owner is not None:
            pulumi.set(__self__, "image_owner", image_owner)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if network_owner is not None:
            pulumi.set(__self__, "network_owner", network_owner)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if template_id is not None:
            pulumi.set(__self__, "template_id", template_id)
        if template_name is not None:
            pulumi.set(__self__, "template_name", template_name)
        if vcpu is not None:
            pulumi.set(__self__, "vcpu", vcpu)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> str:
        """
        Set the user for the XML-RPC API authentication (string)
        """
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="xmlRpcUrl")
    def xml_rpc_url(self) -> str:
        """
        Set the url for the Opennebula XML-RPC API (string)
        """
        return pulumi.get(self, "xml_rpc_url")

    @property
    @pulumi.getter(name="b2dSize")
    def b2d_size(self) -> Optional[str]:
        """
        Size of the Volatile disk in MB - only for b2d (string)
        """
        return pulumi.get(self, "b2d_size")

    @property
    @pulumi.getter
    def cpu(self) -> Optional[str]:
        """
        CPU value for the VM (string)
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="devPrefix")
    def dev_prefix(self) -> Optional[str]:
        """
        Dev prefix to use for the images. E.g.: 'vd', 'sd', 'hd' (string)
        """
        return pulumi.get(self, "dev_prefix")

    @property
    @pulumi.getter(name="disableVnc")
    def disable_vnc(self) -> Optional[bool]:
        """
        VNC is enabled by default. Disable it with this flag (bool)
        """
        return pulumi.get(self, "disable_vnc")

    @property
    @pulumi.getter(name="diskResize")
    def disk_resize(self) -> Optional[str]:
        """
        Size of the disk for the VM in MB (string)
        """
        return pulumi.get(self, "disk_resize")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        """
        OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        """
        OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        """
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter(name="imageOwner")
    def image_owner(self) -> Optional[str]:
        """
        Owner of the image to use as the VM OS (string)
        """
        return pulumi.get(self, "image_owner")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        """
        Size of the memory for the VM in MB (string)
        """
        return pulumi.get(self, "memory")

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[str]:
        """
        Opennebula network ID to connect the machine to. Conflicts with `network_name` (string)
        """
        return pulumi.get(self, "network_id")

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[str]:
        """
        Opennebula network to connect the machine to. Conflicts with `network_id` (string)
        """
        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter(name="networkOwner")
    def network_owner(self) -> Optional[str]:
        """
        Opennebula user ID of the Network to connect the machine to (string)
        """
        return pulumi.get(self, "network_owner")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="templateId")
    def template_id(self) -> Optional[str]:
        """
        Opennebula template ID to use. Conflicts with `template_name` (string)
        """
        return pulumi.get(self, "template_id")

    @property
    @pulumi.getter(name="templateName")
    def template_name(self) -> Optional[str]:
        """
        Name of the Opennbula template to use. Conflicts with `template_id` (string)
        """
        return pulumi.get(self, "template_name")

    @property
    @pulumi.getter
    def vcpu(self) -> Optional[str]:
        """
        VCPUs for the VM (string)
        """
        return pulumi.get(self, "vcpu")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateOpenstackConfig(dict):
    def __init__(__self__, *,
                 auth_url: str,
                 availability_zone: str,
                 region: str,
                 username: str,
                 active_timeout: Optional[str] = None,
                 cacert: Optional[str] = None,
                 config_drive: Optional[bool] = None,
                 domain_id: Optional[str] = None,
                 domain_name: Optional[str] = None,
                 endpoint_type: Optional[str] = None,
                 flavor_id: Optional[str] = None,
                 flavor_name: Optional[str] = None,
                 floating_ip_pool: Optional[str] = None,
                 image_id: Optional[str] = None,
                 image_name: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 ip_version: Optional[str] = None,
                 keypair_name: Optional[str] = None,
                 net_id: Optional[str] = None,
                 net_name: Optional[str] = None,
                 nova_network: Optional[bool] = None,
                 password: Optional[str] = None,
                 private_key_file: Optional[str] = None,
                 sec_groups: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 user_data_file: Optional[str] = None):
        """
        :param str auth_url: OpenStack authentication URL (string)
        :param str availability_zone: OpenStack availability zone (string)
        :param str region: OpenStack region name (string)
        :param str username: vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str active_timeout: OpenStack active timeout Default `200` (string)
        :param str cacert: CA certificate bundle to verify against (string)
        :param bool config_drive: Enables the OpenStack config drive for the instance. Default `false` (bool)
        :param str domain_id: OpenStack domain ID. Identity v3 only. Conflicts with `domain_name` (string)
        :param str domain_name: OpenStack domain name. Identity v3 only. Conflicts with `domain_id` (string)
        :param str endpoint_type: OpenStack endpoint type. adminURL, internalURL or publicURL (string)
        :param str flavor_id: OpenStack flavor id to use for the instance. Conflicts with `flavor_name` (string)
        :param str flavor_name: OpenStack flavor name to use for the instance. Conflicts with `flavor_id` (string)
        :param str floating_ip_pool: OpenStack floating IP pool to get an IP from to assign to the instance (string)
        :param str image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param str image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param bool insecure: Disable TLS credential checking. Default `false` (bool)
        :param str ip_version: OpenStack version of IP address assigned for the machine Default `4` (string)
        :param str keypair_name: OpenStack keypair to use to SSH to the instance (string)
        :param str net_id: OpenStack network id the machine will be connected on. Conflicts with `net_name` (string)
        :param str net_name: OpenStack network name the machine will be connected on. Conflicts with `net_id` (string)
        :param bool nova_network: Use the nova networking services instead of neutron (string)
        :param str password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str private_key_file: Private key content to use for SSH (string)
        :param str sec_groups: OpenStack comma separated security groups for the machine (string)
        :param str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param str tenant_id: OpenStack tenant id. Conflicts with `tenant_name` (string)
        :param str tenant_name: OpenStack tenant name. Conflicts with `tenant_id` (string)
        :param str user_data_file: File containing an openstack userdata script (string)
        """
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "username", username)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if cacert is not None:
            pulumi.set(__self__, "cacert", cacert)
        if config_drive is not None:
            pulumi.set(__self__, "config_drive", config_drive)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if flavor_id is not None:
            pulumi.set(__self__, "flavor_id", flavor_id)
        if flavor_name is not None:
            pulumi.set(__self__, "flavor_name", flavor_name)
        if floating_ip_pool is not None:
            pulumi.set(__self__, "floating_ip_pool", floating_ip_pool)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if ip_version is not None:
            pulumi.set(__self__, "ip_version", ip_version)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if net_id is not None:
            pulumi.set(__self__, "net_id", net_id)
        if net_name is not None:
            pulumi.set(__self__, "net_name", net_name)
        if nova_network is not None:
            pulumi.set(__self__, "nova_network", nova_network)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key_file is not None:
            pulumi.set(__self__, "private_key_file", private_key_file)
        if sec_groups is not None:
            pulumi.set(__self__, "sec_groups", sec_groups)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if user_data_file is not None:
            pulumi.set(__self__, "user_data_file", user_data_file)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        """
        OpenStack authentication URL (string)
        """
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> str:
        """
        OpenStack availability zone (string)
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[str]:
        """
        OpenStack active timeout Default `200` (string)
        """
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter
    def cacert(self) -> Optional[str]:
        """
        CA certificate bundle to verify against (string)
        """
        return pulumi.get(self, "cacert")

    @property
    @pulumi.getter(name="configDrive")
    def config_drive(self) -> Optional[bool]:
        """
        Enables the OpenStack config drive for the instance. Default `false` (bool)
        """
        return pulumi.get(self, "config_drive")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[str]:
        """
        OpenStack domain ID. Identity v3 only. Conflicts with `domain_name` (string)
        """
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[str]:
        """
        OpenStack domain name. Identity v3 only. Conflicts with `domain_id` (string)
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[str]:
        """
        OpenStack endpoint type. adminURL, internalURL or publicURL (string)
        """
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="flavorId")
    def flavor_id(self) -> Optional[str]:
        """
        OpenStack flavor id to use for the instance. Conflicts with `flavor_name` (string)
        """
        return pulumi.get(self, "flavor_id")

    @property
    @pulumi.getter(name="flavorName")
    def flavor_name(self) -> Optional[str]:
        """
        OpenStack flavor name to use for the instance. Conflicts with `flavor_id` (string)
        """
        return pulumi.get(self, "flavor_name")

    @property
    @pulumi.getter(name="floatingIpPool")
    def floating_ip_pool(self) -> Optional[str]:
        """
        OpenStack floating IP pool to get an IP from to assign to the instance (string)
        """
        return pulumi.get(self, "floating_ip_pool")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        """
        OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        """
        OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        """
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[bool]:
        """
        Disable TLS credential checking. Default `false` (bool)
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> Optional[str]:
        """
        OpenStack version of IP address assigned for the machine Default `4` (string)
        """
        return pulumi.get(self, "ip_version")

    @property
    @pulumi.getter(name="keypairName")
    def keypair_name(self) -> Optional[str]:
        """
        OpenStack keypair to use to SSH to the instance (string)
        """
        return pulumi.get(self, "keypair_name")

    @property
    @pulumi.getter(name="netId")
    def net_id(self) -> Optional[str]:
        """
        OpenStack network id the machine will be connected on. Conflicts with `net_name` (string)
        """
        return pulumi.get(self, "net_id")

    @property
    @pulumi.getter(name="netName")
    def net_name(self) -> Optional[str]:
        """
        OpenStack network name the machine will be connected on. Conflicts with `net_id` (string)
        """
        return pulumi.get(self, "net_name")

    @property
    @pulumi.getter(name="novaNetwork")
    def nova_network(self) -> Optional[bool]:
        """
        Use the nova networking services instead of neutron (string)
        """
        return pulumi.get(self, "nova_network")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="privateKeyFile")
    def private_key_file(self) -> Optional[str]:
        """
        Private key content to use for SSH (string)
        """
        return pulumi.get(self, "private_key_file")

    @property
    @pulumi.getter(name="secGroups")
    def sec_groups(self) -> Optional[str]:
        """
        OpenStack comma separated security groups for the machine (string)
        """
        return pulumi.get(self, "sec_groups")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        OpenStack tenant id. Conflicts with `tenant_name` (string)
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[str]:
        """
        OpenStack tenant name. Conflicts with `tenant_id` (string)
        """
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="userDataFile")
    def user_data_file(self) -> Optional[str]:
        """
        File containing an openstack userdata script (string)
        """
        return pulumi.get(self, "user_data_file")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NodeTemplateVsphereConfig(dict):
    def __init__(__self__, *,
                 boot2docker_url: Optional[str] = None,
                 cfgparams: Optional[List[str]] = None,
                 clone_from: Optional[str] = None,
                 cloud_config: Optional[str] = None,
                 cloudinit: Optional[str] = None,
                 content_library: Optional[str] = None,
                 cpu_count: Optional[str] = None,
                 creation_type: Optional[str] = None,
                 custom_attributes: Optional[List[str]] = None,
                 datacenter: Optional[str] = None,
                 datastore: Optional[str] = None,
                 datastore_cluster: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 folder: Optional[str] = None,
                 hostsystem: Optional[str] = None,
                 memory_size: Optional[str] = None,
                 networks: Optional[List[str]] = None,
                 password: Optional[str] = None,
                 pool: Optional[str] = None,
                 ssh_password: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 ssh_user_group: Optional[str] = None,
                 tags: Optional[List[str]] = None,
                 username: Optional[str] = None,
                 vapp_ip_allocation_policy: Optional[str] = None,
                 vapp_ip_protocol: Optional[str] = None,
                 vapp_properties: Optional[List[str]] = None,
                 vapp_transport: Optional[str] = None,
                 vcenter: Optional[str] = None,
                 vcenter_port: Optional[str] = None):
        """
        :param str boot2docker_url: vSphere URL for boot2docker iso image. Default `https://releases.rancher.com/os/latest/rancheros-vmware.iso` (string)
        :param List[str] cfgparams: vSphere vm configuration parameters (used for guestinfo) (list)
        :param str clone_from: If you choose creation type vm (clone vm) a name of what vm you want to clone is required. From Rancher v2.3.3 (string)
        :param str cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data. From Rancher v2.3.3 (string)
        :param str cloudinit: vSphere cloud-init file or url to set in the guestinfo (string)
        :param str content_library: If you choose to clone from a content library template specify the name of the library. From Rancher v2.3.3 (string)
        :param str cpu_count: vSphere CPU number for docker VM. Default `2` (string)
        :param str creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy. Default `legacy`. From Rancher v2.3.3 (string)
        :param List[str] custom_attributes: vSphere custom attributes, format key/value e.g. `200=my custom value`. From Rancher v2.3.3 (List)
        :param str datacenter: vSphere datacenter for docker VM (string)
        :param str datastore: vSphere datastore for docker VM (string)
        :param str datastore_cluster: vSphere datastore cluster for virtual machine. From Rancher v2.3.3 (string)
        :param str disk_size: vSphere size of disk for docker VM (in MB). Default `20480` (string)
        :param str folder: vSphere folder for the docker VM. This folder must already exist in the datacenter (string)
        :param str hostsystem: vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS (string)
        :param str memory_size: vSphere size of memory for docker VM (in MB). Default `2048` (string)
        :param List[str] networks: vSphere network where the docker VM will be attached (list)
        :param str password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str pool: vSphere resource pool for docker VM (string)
        :param str ssh_password: If using a non-B2D image you can specify the ssh password. Default `tcuser`. From Rancher v2.3.3 (string)
        :param str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param str ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed. Default `staff`. From Rancher v2.3.3 (string)
        :param List[str] tags: vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        :param str username: vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: `dhcp`, `fixed`, `transient` and `fixedAllocated` (string)
        :param str vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: `IPv4` and `IPv6` (string)
        :param List[str] vapp_properties: vSphere vApp properties (list)
        :param str vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: `iso` and `com.vmware.guestInfo` (string)
        :param str vcenter: vSphere IP/hostname for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param str vcenter_port: vSphere Port for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x. Default `443` (string)
        """
        if boot2docker_url is not None:
            pulumi.set(__self__, "boot2docker_url", boot2docker_url)
        if cfgparams is not None:
            pulumi.set(__self__, "cfgparams", cfgparams)
        if clone_from is not None:
            pulumi.set(__self__, "clone_from", clone_from)
        if cloud_config is not None:
            pulumi.set(__self__, "cloud_config", cloud_config)
        if cloudinit is not None:
            pulumi.set(__self__, "cloudinit", cloudinit)
        if content_library is not None:
            pulumi.set(__self__, "content_library", content_library)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if creation_type is not None:
            pulumi.set(__self__, "creation_type", creation_type)
        if custom_attributes is not None:
            pulumi.set(__self__, "custom_attributes", custom_attributes)
        if datacenter is not None:
            pulumi.set(__self__, "datacenter", datacenter)
        if datastore is not None:
            pulumi.set(__self__, "datastore", datastore)
        if datastore_cluster is not None:
            pulumi.set(__self__, "datastore_cluster", datastore_cluster)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if hostsystem is not None:
            pulumi.set(__self__, "hostsystem", hostsystem)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if pool is not None:
            pulumi.set(__self__, "pool", pool)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if ssh_user_group is not None:
            pulumi.set(__self__, "ssh_user_group", ssh_user_group)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if vapp_ip_allocation_policy is not None:
            pulumi.set(__self__, "vapp_ip_allocation_policy", vapp_ip_allocation_policy)
        if vapp_ip_protocol is not None:
            pulumi.set(__self__, "vapp_ip_protocol", vapp_ip_protocol)
        if vapp_properties is not None:
            pulumi.set(__self__, "vapp_properties", vapp_properties)
        if vapp_transport is not None:
            pulumi.set(__self__, "vapp_transport", vapp_transport)
        if vcenter is not None:
            pulumi.set(__self__, "vcenter", vcenter)
        if vcenter_port is not None:
            pulumi.set(__self__, "vcenter_port", vcenter_port)

    @property
    @pulumi.getter(name="boot2dockerUrl")
    def boot2docker_url(self) -> Optional[str]:
        """
        vSphere URL for boot2docker iso image. Default `https://releases.rancher.com/os/latest/rancheros-vmware.iso` (string)
        """
        return pulumi.get(self, "boot2docker_url")

    @property
    @pulumi.getter
    def cfgparams(self) -> Optional[List[str]]:
        """
        vSphere vm configuration parameters (used for guestinfo) (list)
        """
        return pulumi.get(self, "cfgparams")

    @property
    @pulumi.getter(name="cloneFrom")
    def clone_from(self) -> Optional[str]:
        """
        If you choose creation type vm (clone vm) a name of what vm you want to clone is required. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "clone_from")

    @property
    @pulumi.getter(name="cloudConfig")
    def cloud_config(self) -> Optional[str]:
        """
        Filepath to a cloud-config yaml file to put into the ISO user-data. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "cloud_config")

    @property
    @pulumi.getter
    def cloudinit(self) -> Optional[str]:
        """
        vSphere cloud-init file or url to set in the guestinfo (string)
        """
        return pulumi.get(self, "cloudinit")

    @property
    @pulumi.getter(name="contentLibrary")
    def content_library(self) -> Optional[str]:
        """
        If you choose to clone from a content library template specify the name of the library. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "content_library")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[str]:
        """
        vSphere CPU number for docker VM. Default `2` (string)
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="creationType")
    def creation_type(self) -> Optional[str]:
        """
        Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy. Default `legacy`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "creation_type")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[List[str]]:
        """
        vSphere custom attributes, format key/value e.g. `200=my custom value`. From Rancher v2.3.3 (List)
        """
        return pulumi.get(self, "custom_attributes")

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[str]:
        """
        vSphere datacenter for docker VM (string)
        """
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def datastore(self) -> Optional[str]:
        """
        vSphere datastore for docker VM (string)
        """
        return pulumi.get(self, "datastore")

    @property
    @pulumi.getter(name="datastoreCluster")
    def datastore_cluster(self) -> Optional[str]:
        """
        vSphere datastore cluster for virtual machine. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "datastore_cluster")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[str]:
        """
        vSphere size of disk for docker VM (in MB). Default `20480` (string)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        """
        vSphere folder for the docker VM. This folder must already exist in the datacenter (string)
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def hostsystem(self) -> Optional[str]:
        """
        vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS (string)
        """
        return pulumi.get(self, "hostsystem")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[str]:
        """
        vSphere size of memory for docker VM (in MB). Default `2048` (string)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter
    def networks(self) -> Optional[List[str]]:
        """
        vSphere network where the docker VM will be attached (list)
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def pool(self) -> Optional[str]:
        """
        vSphere resource pool for docker VM (string)
        """
        return pulumi.get(self, "pool")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh password. Default `tcuser`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="sshUserGroup")
    def ssh_user_group(self) -> Optional[str]:
        """
        If using a non-B2D image the uploaded keys will need chown'ed. Default `staff`. From Rancher v2.3.3 (string)
        """
        return pulumi.get(self, "ssh_user_group")

    @property
    @pulumi.getter
    def tags(self) -> Optional[List[str]]:
        """
        vSphere tags id e.g. `urn:xxx`. From Rancher v2.3.3 (list)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vappIpAllocationPolicy")
    def vapp_ip_allocation_policy(self) -> Optional[str]:
        """
        vSphere vApp IP allocation policy. Supported values are: `dhcp`, `fixed`, `transient` and `fixedAllocated` (string)
        """
        return pulumi.get(self, "vapp_ip_allocation_policy")

    @property
    @pulumi.getter(name="vappIpProtocol")
    def vapp_ip_protocol(self) -> Optional[str]:
        """
        vSphere vApp IP protocol for this deployment. Supported values are: `IPv4` and `IPv6` (string)
        """
        return pulumi.get(self, "vapp_ip_protocol")

    @property
    @pulumi.getter(name="vappProperties")
    def vapp_properties(self) -> Optional[List[str]]:
        """
        vSphere vApp properties (list)
        """
        return pulumi.get(self, "vapp_properties")

    @property
    @pulumi.getter(name="vappTransport")
    def vapp_transport(self) -> Optional[str]:
        """
        vSphere OVF environment transports to use for properties. Supported values are: `iso` and `com.vmware.guestInfo` (string)
        """
        return pulumi.get(self, "vapp_transport")

    @property
    @pulumi.getter
    def vcenter(self) -> Optional[str]:
        """
        vSphere IP/hostname for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        """
        return pulumi.get(self, "vcenter")

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[str]:
        """
        vSphere Port for vCenter. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x. Default `443` (string)
        """
        return pulumi.get(self, "vcenter_port")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NotifierPagerdutyConfig(dict):
    def __init__(__self__, *,
                 service_key: str,
                 proxy_url: Optional[str] = None):
        """
        :param str service_key: Pagerduty service key (string)
        :param str proxy_url: Wechat proxy url (string)
        """
        pulumi.set(__self__, "service_key", service_key)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="serviceKey")
    def service_key(self) -> str:
        """
        Pagerduty service key (string)
        """
        return pulumi.get(self, "service_key")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NotifierSlackConfig(dict):
    def __init__(__self__, *,
                 default_recipient: str,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str default_recipient: Wechat default recipient (string)
        :param str url: Webhook url (string)
        :param str proxy_url: Wechat proxy url (string)
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        Wechat default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook url (string)
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NotifierSmtpConfig(dict):
    def __init__(__self__, *,
                 default_recipient: str,
                 host: str,
                 port: float,
                 sender: str,
                 password: Optional[str] = None,
                 tls: Optional[bool] = None,
                 username: Optional[str] = None):
        """
        :param str default_recipient: Wechat default recipient (string)
        :param str host: SMTP host (string)
        :param float port: SMTP port (int)
        :param str sender: SMTP sender (string)
        :param str password: SMTP password (string)
        :param bool tls: SMTP tls. Default `true` (bool)
        :param 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) -> str:
        """
        Wechat default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        SMTP host (string)
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> float:
        """
        SMTP port (int)
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def sender(self) -> str:
        """
        SMTP sender (string)
        """
        return pulumi.get(self, "sender")

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

    @property
    @pulumi.getter
    def tls(self) -> Optional[bool]:
        """
        SMTP tls. Default `true` (bool)
        """
        return pulumi.get(self, "tls")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NotifierWebhookConfig(dict):
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str url: Webhook url (string)
        :param str proxy_url: Wechat proxy url (string)
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook url (string)
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NotifierWechatConfig(dict):
    def __init__(__self__, *,
                 agent: str,
                 corp: str,
                 default_recipient: str,
                 secret: str,
                 proxy_url: Optional[str] = None,
                 recipient_type: Optional[str] = None):
        """
        :param str agent: Wechat agent ID (string)
        :param str corp: Wechat corporation ID (string)
        :param str default_recipient: Wechat default recipient (string)
        :param str secret: Wechat agent ID (string)
        :param str proxy_url: Wechat proxy url (string)
        :param str recipient_type: Wechat recipient type. Allowed values: `party` | `tag` | `user` (string)
        """
        pulumi.set(__self__, "agent", agent)
        pulumi.set(__self__, "corp", corp)
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "secret", secret)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if recipient_type is not None:
            pulumi.set(__self__, "recipient_type", recipient_type)

    @property
    @pulumi.getter
    def agent(self) -> str:
        """
        Wechat agent ID (string)
        """
        return pulumi.get(self, "agent")

    @property
    @pulumi.getter
    def corp(self) -> str:
        """
        Wechat corporation ID (string)
        """
        return pulumi.get(self, "corp")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        Wechat default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        Wechat agent ID (string)
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Wechat proxy url (string)
        """
        return pulumi.get(self, "proxy_url")

    @property
    @pulumi.getter(name="recipientType")
    def recipient_type(self) -> Optional[str]:
        """
        Wechat recipient type. Allowed values: `party` | `tag` | `user` (string)
        """
        return pulumi.get(self, "recipient_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedCsiDriver(dict):
    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")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedFlexVolume(dict):
    def __init__(__self__, *,
                 driver: str):
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> str:
        return pulumi.get(self, "driver")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedHostPath(dict):
    def __init__(__self__, *,
                 path_prefix: str,
                 read_only: Optional[bool] = None):
        """
        :param str path_prefix: (string)
        :param bool read_only: (string)
        """
        pulumi.set(__self__, "path_prefix", path_prefix)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="pathPrefix")
    def path_prefix(self) -> str:
        """
        (string)
        """
        return pulumi.get(self, "path_prefix")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateFsGroup(dict):
    def __init__(__self__, *,
                 ranges: Optional[List['outputs.PodSecurityPolicyTemplateFsGroupRange']] = None,
                 rule: Optional[str] = None):
        """
        :param List['PodSecurityPolicyTemplateFsGroupRangeArgs'] ranges: (list)
        :param str rule: (string)
        """
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['outputs.PodSecurityPolicyTemplateFsGroupRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateFsGroupRange(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        """
        :param float max: (int)
        :param float min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "min")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateHostPort(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        """
        :param float max: (int)
        :param float min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "min")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsGroup(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[List['outputs.PodSecurityPolicyTemplateRunAsGroupRange']] = None):
        """
        :param str rule: (string)
        :param List['PodSecurityPolicyTemplateRunAsGroupRangeArgs'] ranges: (list)
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['outputs.PodSecurityPolicyTemplateRunAsGroupRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsGroupRange(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        """
        :param float max: (int)
        :param float min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "min")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsUser(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[List['outputs.PodSecurityPolicyTemplateRunAsUserRange']] = None):
        """
        :param str rule: (string)
        :param List['PodSecurityPolicyTemplateRunAsUserRangeArgs'] ranges: (list)
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['outputs.PodSecurityPolicyTemplateRunAsUserRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsUserRange(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        """
        :param float max: (int)
        :param float min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "min")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateRuntimeClass(dict):
    def __init__(__self__, *,
                 allowed_runtime_class_names: List[str],
                 default_runtime_class_name: Optional[str] = None):
        """
        :param List[str] allowed_runtime_class_names: (list)
        :param str default_runtime_class_name: (string)
        """
        pulumi.set(__self__, "allowed_runtime_class_names", allowed_runtime_class_names)
        if default_runtime_class_name is not None:
            pulumi.set(__self__, "default_runtime_class_name", default_runtime_class_name)

    @property
    @pulumi.getter(name="allowedRuntimeClassNames")
    def allowed_runtime_class_names(self) -> List[str]:
        """
        (list)
        """
        return pulumi.get(self, "allowed_runtime_class_names")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateSeLinux(dict):
    def __init__(__self__, *,
                 rule: str,
                 se_linux_option: Optional['outputs.PodSecurityPolicyTemplateSeLinuxSeLinuxOption'] = None):
        """
        :param str rule: (string)
        :param 'PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs' se_linux_option: (list maxitems:1)
        """
        pulumi.set(__self__, "rule", rule)
        if se_linux_option is not None:
            pulumi.set(__self__, "se_linux_option", se_linux_option)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        (string)
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter(name="seLinuxOption")
    def se_linux_option(self) -> Optional['outputs.PodSecurityPolicyTemplateSeLinuxSeLinuxOption']:
        """
        (list maxitems:1)
        """
        return pulumi.get(self, "se_linux_option")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateSeLinuxSeLinuxOption(dict):
    def __init__(__self__, *,
                 level: Optional[str] = None,
                 role: Optional[str] = None,
                 type: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :param str level: (string)
        :param str role: (string)
        :param str type: (string)
        :param str user: (string)
        """
        if level is not None:
            pulumi.set(__self__, "level", level)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateSupplementalGroup(dict):
    def __init__(__self__, *,
                 ranges: Optional[List['outputs.PodSecurityPolicyTemplateSupplementalGroupRange']] = None,
                 rule: Optional[str] = None):
        """
        :param List['PodSecurityPolicyTemplateSupplementalGroupRangeArgs'] ranges: (list)
        :param str rule: (string)
        """
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['outputs.PodSecurityPolicyTemplateSupplementalGroupRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PodSecurityPolicyTemplateSupplementalGroupRange(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        """
        :param float max: (int)
        :param float min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        """
        (int)
        """
        return pulumi.get(self, "min")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectAlertGroupRecipient(dict):
    def __init__(__self__, *,
                 notifier_id: str,
                 default_recipient: Optional[bool] = None,
                 notifier_type: Optional[str] = None,
                 recipient: Optional[str] = None):
        """
        :param str notifier_id: Recipient notifier ID (string)
        :param str notifier_type: Recipient notifier ID. Supported values : `"pagerduty" | "slack" | "email" | "webhook" | "wechat"` (string)
        :param str recipient: Recipient (string)
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)
        if notifier_type is not None:
            pulumi.set(__self__, "notifier_type", notifier_type)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectAlertRulePodRule(dict):
    def __init__(__self__, *,
                 pod_id: str,
                 condition: Optional[str] = None,
                 restart_interval_seconds: Optional[float] = None,
                 restart_times: Optional[float] = None):
        """
        :param str pod_id: Pod ID (string)
        :param str condition: Pod rule condition. Supported values : `"notrunning" | "notscheduled" | "restarts"`. Default: `notrunning` (string)
        :param float restart_interval_seconds: Pod rule restart interval seconds. Default: `300` (int)
        :param float restart_times: Pod rule restart times. Default: `3`  (int)
        """
        pulumi.set(__self__, "pod_id", pod_id)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if restart_interval_seconds is not None:
            pulumi.set(__self__, "restart_interval_seconds", restart_interval_seconds)
        if restart_times is not None:
            pulumi.set(__self__, "restart_times", restart_times)

    @property
    @pulumi.getter(name="podId")
    def pod_id(self) -> str:
        """
        Pod ID (string)
        """
        return pulumi.get(self, "pod_id")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        Pod rule condition. Supported values : `"notrunning" | "notscheduled" | "restarts"`. Default: `notrunning` (string)
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="restartIntervalSeconds")
    def restart_interval_seconds(self) -> Optional[float]:
        """
        Pod rule restart interval seconds. Default: `300` (int)
        """
        return pulumi.get(self, "restart_interval_seconds")

    @property
    @pulumi.getter(name="restartTimes")
    def restart_times(self) -> Optional[float]:
        """
        Pod rule restart times. Default: `3`  (int)
        """
        return pulumi.get(self, "restart_times")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectAlertRuleWorkloadRule(dict):
    def __init__(__self__, *,
                 available_percentage: Optional[float] = None,
                 selector: Optional[Mapping[str, Any]] = None,
                 workload_id: Optional[str] = None):
        """
        :param float available_percentage: Workload rule available percentage. Default: `70` (int)
        :param Mapping[str, Any] selector: Workload rule selector (map)
        :param str workload_id: Workload ID (string)
        """
        if available_percentage is not None:
            pulumi.set(__self__, "available_percentage", available_percentage)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if workload_id is not None:
            pulumi.set(__self__, "workload_id", workload_id)

    @property
    @pulumi.getter(name="availablePercentage")
    def available_percentage(self) -> Optional[float]:
        """
        Workload rule available percentage. Default: `70` (int)
        """
        return pulumi.get(self, "available_percentage")

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

    @property
    @pulumi.getter(name="workloadId")
    def workload_id(self) -> Optional[str]:
        """
        Workload ID (string)
        """
        return pulumi.get(self, "workload_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectContainerResourceLimit(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None):
        """
        :param str limits_cpu: Limit for limits cpu in project (string)
        :param str limits_memory: Limit for limits memory in project (string)
        :param str requests_cpu: Limit for requests cpu in project (string)
        :param str requests_memory: Limit for requests memory in project (string)
        """
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectLoggingFluentdConfig(dict):
    def __init__(__self__, *,
                 fluent_servers: List['outputs.ProjectLoggingFluentdConfigFluentServer'],
                 certificate: Optional[str] = None,
                 compress: Optional[bool] = None,
                 enable_tls: Optional[bool] = None):
        """
        :param List['ProjectLoggingFluentdConfigFluentServerArgs'] fluent_servers: Servers for the fluentd service (list)
        :param str certificate: SSL certificate for the syslog service (string)
        :param bool compress: Compress data for the fluentd service (bool)
        :param bool enable_tls: Enable TLS for the fluentd service (bool)
        """
        pulumi.set(__self__, "fluent_servers", fluent_servers)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

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

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

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

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectResourceQuota(dict):
    def __init__(__self__, *,
                 namespace_default_limit: 'outputs.ProjectResourceQuotaNamespaceDefaultLimit',
                 project_limit: 'outputs.ProjectResourceQuotaProjectLimit'):
        """
        :param 'ProjectResourceQuotaNamespaceDefaultLimitArgs' namespace_default_limit: Default resource quota limit for  namespaces in project (list maxitems:1)
        :param 'ProjectResourceQuotaProjectLimitArgs' project_limit: Resource quota limit for project (list maxitems:1)
        """
        pulumi.set(__self__, "namespace_default_limit", namespace_default_limit)
        pulumi.set(__self__, "project_limit", project_limit)

    @property
    @pulumi.getter(name="namespaceDefaultLimit")
    def namespace_default_limit(self) -> 'outputs.ProjectResourceQuotaNamespaceDefaultLimit':
        """
        Default resource quota limit for  namespaces in project (list maxitems:1)
        """
        return pulumi.get(self, "namespace_default_limit")

    @property
    @pulumi.getter(name="projectLimit")
    def project_limit(self) -> 'outputs.ProjectResourceQuotaProjectLimit':
        """
        Resource quota limit for project (list maxitems:1)
        """
        return pulumi.get(self, "project_limit")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectResourceQuotaNamespaceDefaultLimit(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        """
        :param str config_maps: Limit for config maps in project (string)
        :param str limits_cpu: Limit for limits cpu in project (string)
        :param str limits_memory: Limit for limits memory in project (string)
        :param str persistent_volume_claims: Limit for persistent volume claims in project (string)
        :param str pods: Limit for pods in project (string)
        :param str replication_controllers: Limit for replication controllers in project (string)
        :param str requests_cpu: Limit for requests cpu in project (string)
        :param str requests_memory: Limit for requests memory in project (string)
        :param str requests_storage: Limit for requests storage in project (string)
        :param str secrets: Limit for secrets in project (string)
        :param str services_load_balancers: Limit for services load balancers in project (string)
        :param str services_node_ports: Limit for services node ports in project (string)
        """
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        """
        Limit for config maps in project (string)
        """
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        """
        Limit for persistent volume claims in project (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        """
        Limit for pods in project (string)
        """
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        """
        Limit for replication controllers in project (string)
        """
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        """
        Limit for requests storage in project (string)
        """
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        """
        Limit for secrets in project (string)
        """
        return pulumi.get(self, "secrets")

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

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        """
        Limit for services load balancers in project (string)
        """
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        """
        Limit for services node ports in project (string)
        """
        return pulumi.get(self, "services_node_ports")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProjectResourceQuotaProjectLimit(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        """
        :param str config_maps: Limit for config maps in project (string)
        :param str limits_cpu: Limit for limits cpu in project (string)
        :param str limits_memory: Limit for limits memory in project (string)
        :param str persistent_volume_claims: Limit for persistent volume claims in project (string)
        :param str pods: Limit for pods in project (string)
        :param str replication_controllers: Limit for replication controllers in project (string)
        :param str requests_cpu: Limit for requests cpu in project (string)
        :param str requests_memory: Limit for requests memory in project (string)
        :param str requests_storage: Limit for requests storage in project (string)
        :param str secrets: Limit for secrets in project (string)
        :param str services_load_balancers: Limit for services load balancers in project (string)
        :param str services_node_ports: Limit for services node ports in project (string)
        """
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        """
        Limit for config maps in project (string)
        """
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        """
        Limit for persistent volume claims in project (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        """
        Limit for pods in project (string)
        """
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        """
        Limit for replication controllers in project (string)
        """
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        """
        Limit for requests storage in project (string)
        """
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        """
        Limit for secrets in project (string)
        """
        return pulumi.get(self, "secrets")

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

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        """
        Limit for services load balancers in project (string)
        """
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        """
        Limit for services node ports in project (string)
        """
        return pulumi.get(self, "services_node_ports")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class RegistryRegistry(dict):
    def __init__(__self__, *,
                 address: str,
                 password: Optional[str] = None,
                 username: Optional[str] = None):
        """
        :param str address: Address for registry.
        :param str password: Password for the registry (string)
        :param str username: Username for the registry (string)
        """
        pulumi.set(__self__, "address", address)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def address(self) -> str:
        """
        Address for registry.
        """
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        Password for the registry (string)
        """
        return pulumi.get(self, "password")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class RoleTempalteRule(dict):
    def __init__(__self__, *,
                 api_groups: Optional[List[str]] = None,
                 non_resource_urls: Optional[List[str]] = None,
                 resource_names: Optional[List[str]] = None,
                 resources: Optional[List[str]] = None,
                 verbs: Optional[List[str]] = None):
        """
        :param List[str] api_groups: Policy rule api groups (list)
        :param List[str] non_resource_urls: Policy rule non resource urls (list)
        :param List[str] resource_names: Policy rule resource names (list)
        :param List[str] resources: Policy rule resources (list)
        :param List[str] verbs: Policy rule verbs. `create`, `delete`, `get`, `list`, `patch`, `update`, `view`, `watch` and `*` values are supported (list)
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[List[str]]:
        """
        Policy rule api groups (list)
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[List[str]]:
        """
        Policy rule non resource urls (list)
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[List[str]]:
        """
        Policy rule resource names (list)
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[List[str]]:
        """
        Policy rule resources (list)
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[List[str]]:
        """
        Policy rule verbs. `create`, `delete`, `get`, `list`, `patch`, `update`, `view`, `watch` and `*` values are supported (list)
        """
        return pulumi.get(self, "verbs")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class GetClusterAksConfigResult(dict):
    def __init__(__self__, *,
                 agent_dns_prefix: str,
                 client_id: str,
                 client_secret: str,
                 kubernetes_version: str,
                 master_dns_prefix: str,
                 resource_group: str,
                 ssh_public_key_contents: str,
                 subnet: str,
                 subscription_id: str,
                 tag: Mapping[str, Any],
                 tenant_id: str,
                 virtual_network: str,
                 virtual_network_resource_group: str,
                 aad_server_app_secret: Optional[str] = None,
                 aad_tenant_id: Optional[str] = None,
                 add_client_app_id: Optional[str] = None,
                 add_server_app_id: Optional[str] = None,
                 admin_username: Optional[str] = None,
                 agent_os_disk_size: Optional[float] = None,
                 agent_pool_name: Optional[str] = None,
                 agent_storage_profile: Optional[str] = None,
                 agent_vm_size: Optional[str] = None,
                 auth_base_url: Optional[str] = None,
                 base_url: Optional[str] = None,
                 count: Optional[float] = None,
                 dns_service_ip: Optional[str] = None,
                 docker_bridge_cidr: Optional[str] = None,
                 enable_http_application_routing: Optional[bool] = None,
                 enable_monitoring: Optional[bool] = None,
                 location: Optional[str] = None,
                 log_analytics_workspace: Optional[str] = None,
                 log_analytics_workspace_resource_group: Optional[str] = None,
                 max_pods: Optional[float] = None,
                 network_plugin: Optional[str] = None,
                 network_policy: Optional[str] = None,
                 pod_cidr: Optional[str] = None,
                 service_cidr: Optional[str] = None):
        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__, "tag", tag)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "virtual_network", virtual_network)
        pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)
        if aad_server_app_secret is not None:
            pulumi.set(__self__, "aad_server_app_secret", aad_server_app_secret)
        if aad_tenant_id is not None:
            pulumi.set(__self__, "aad_tenant_id", aad_tenant_id)
        if add_client_app_id is not None:
            pulumi.set(__self__, "add_client_app_id", add_client_app_id)
        if add_server_app_id is not None:
            pulumi.set(__self__, "add_server_app_id", add_server_app_id)
        if admin_username is not None:
            pulumi.set(__self__, "admin_username", admin_username)
        if agent_os_disk_size is not None:
            pulumi.set(__self__, "agent_os_disk_size", agent_os_disk_size)
        if agent_pool_name is not None:
            pulumi.set(__self__, "agent_pool_name", agent_pool_name)
        if agent_storage_profile is not None:
            pulumi.set(__self__, "agent_storage_profile", agent_storage_profile)
        if agent_vm_size is not None:
            pulumi.set(__self__, "agent_vm_size", agent_vm_size)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if dns_service_ip is not None:
            pulumi.set(__self__, "dns_service_ip", dns_service_ip)
        if docker_bridge_cidr is not None:
            pulumi.set(__self__, "docker_bridge_cidr", docker_bridge_cidr)
        if enable_http_application_routing is not None:
            pulumi.set(__self__, "enable_http_application_routing", enable_http_application_routing)
        if enable_monitoring is not None:
            pulumi.set(__self__, "enable_monitoring", enable_monitoring)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if log_analytics_workspace is not None:
            pulumi.set(__self__, "log_analytics_workspace", log_analytics_workspace)
        if log_analytics_workspace_resource_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_resource_group", log_analytics_workspace_resource_group)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)

    @property
    @pulumi.getter(name="agentDnsPrefix")
    def agent_dns_prefix(self) -> str:
        return pulumi.get(self, "agent_dns_prefix")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="masterDnsPrefix")
    def master_dns_prefix(self) -> str:
        return pulumi.get(self, "master_dns_prefix")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="sshPublicKeyContents")
    def ssh_public_key_contents(self) -> str:
        return pulumi.get(self, "ssh_public_key_contents")

    @property
    @pulumi.getter
    def subnet(self) -> str:
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

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

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> str:
        return pulumi.get(self, "virtual_network")

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> str:
        return pulumi.get(self, "virtual_network_resource_group")

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def count(self) -> Optional[float]:
        return pulumi.get(self, "count")

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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


@pulumi.output_type
class GetClusterClusterAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[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[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

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


@pulumi.output_type
class GetClusterClusterMonitoringInputResult(dict):
    def __init__(__self__, *,
                 answers: Optional[Mapping[str, Any]] = None,
                 version: Optional[str] = None):
        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[Mapping[str, Any]]:
        return pulumi.get(self, "answers")

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


@pulumi.output_type
class GetClusterClusterRegistrationTokenResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cluster_id: str,
                 command: str,
                 id: str,
                 insecure_command: str,
                 labels: Mapping[str, Any],
                 manifest_url: str,
                 name: str,
                 node_command: str,
                 token: str,
                 windows_node_command: str):
        """
        :param Mapping[str, Any] annotations: (Computed) Annotations for Node Pool object (map)
        :param str id: (Computed) The ID of the resource (string)
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "annotations", annotations)
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "insecure_command", insecure_command)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "manifest_url", manifest_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "node_command", node_command)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Mapping[str, Any]:
        """
        (Computed) Annotations for Node Pool object (map)
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> str:
        return pulumi.get(self, "command")

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

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> str:
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> str:
        return pulumi.get(self, "manifest_url")

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

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> str:
        return pulumi.get(self, "node_command")

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

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> str:
        return pulumi.get(self, "windows_node_command")


@pulumi.output_type
class GetClusterClusterTemplateAnswersResult(dict):
    def __init__(__self__, *,
                 cluster_id: str,
                 project_id: str,
                 values: Mapping[str, Any]):
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        return pulumi.get(self, "project_id")

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


@pulumi.output_type
class GetClusterClusterTemplateQuestionResult(dict):
    def __init__(__self__, *,
                 default: str,
                 variable: str,
                 required: Optional[bool] = None,
                 type: Optional[str] = None):
        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) -> str:
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> str:
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[bool]:
        return pulumi.get(self, "required")

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


@pulumi.output_type
class GetClusterEksConfigResult(dict):
    def __init__(__self__, *,
                 access_key: str,
                 kubernetes_version: str,
                 secret_key: str,
                 user_data: str,
                 ami: Optional[str] = None,
                 associate_worker_node_public_ip: Optional[bool] = None,
                 desired_nodes: Optional[float] = None,
                 instance_type: Optional[str] = None,
                 key_pair_name: Optional[str] = None,
                 maximum_nodes: Optional[float] = None,
                 minimum_nodes: Optional[float] = None,
                 node_volume_size: Optional[float] = None,
                 region: Optional[str] = None,
                 security_groups: Optional[List[str]] = None,
                 service_role: Optional[str] = None,
                 session_token: Optional[str] = None,
                 subnets: Optional[List[str]] = None,
                 virtual_network: Optional[str] = None):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "secret_key", secret_key)
        pulumi.set(__self__, "user_data", user_data)
        if ami is not None:
            pulumi.set(__self__, "ami", ami)
        if associate_worker_node_public_ip is not None:
            pulumi.set(__self__, "associate_worker_node_public_ip", associate_worker_node_public_ip)
        if desired_nodes is not None:
            pulumi.set(__self__, "desired_nodes", desired_nodes)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if key_pair_name is not None:
            pulumi.set(__self__, "key_pair_name", key_pair_name)
        if maximum_nodes is not None:
            pulumi.set(__self__, "maximum_nodes", maximum_nodes)
        if minimum_nodes is not None:
            pulumi.set(__self__, "minimum_nodes", minimum_nodes)
        if node_volume_size is not None:
            pulumi.set(__self__, "node_volume_size", node_volume_size)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if service_role is not None:
            pulumi.set(__self__, "service_role", service_role)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if virtual_network is not None:
            pulumi.set(__self__, "virtual_network", virtual_network)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> str:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> str:
        return pulumi.get(self, "user_data")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[List[str]]:
        return pulumi.get(self, "security_groups")

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

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

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

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


@pulumi.output_type
class GetClusterGkeConfigResult(dict):
    def __init__(__self__, *,
                 cluster_ipv4_cidr: str,
                 credential: str,
                 disk_type: str,
                 image_type: str,
                 ip_policy_cluster_ipv4_cidr_block: str,
                 ip_policy_cluster_secondary_range_name: str,
                 ip_policy_node_ipv4_cidr_block: str,
                 ip_policy_services_ipv4_cidr_block: str,
                 ip_policy_services_secondary_range_name: str,
                 ip_policy_subnetwork_name: str,
                 labels: Mapping[str, Any],
                 locations: List[str],
                 machine_type: str,
                 maintenance_window: str,
                 master_ipv4_cidr_block: str,
                 master_version: str,
                 network: str,
                 node_pool: str,
                 node_version: str,
                 oauth_scopes: List[str],
                 project_id: str,
                 resource_labels: Mapping[str, Any],
                 service_account: str,
                 sub_network: str,
                 description: Optional[str] = None,
                 disk_size_gb: Optional[float] = None,
                 enable_alpha_feature: Optional[bool] = None,
                 enable_auto_repair: Optional[bool] = None,
                 enable_auto_upgrade: Optional[bool] = None,
                 enable_horizontal_pod_autoscaling: Optional[bool] = None,
                 enable_http_load_balancing: Optional[bool] = None,
                 enable_kubernetes_dashboard: Optional[bool] = None,
                 enable_legacy_abac: Optional[bool] = None,
                 enable_master_authorized_network: Optional[bool] = None,
                 enable_network_policy_config: Optional[bool] = None,
                 enable_nodepool_autoscaling: Optional[bool] = None,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None,
                 enable_stackdriver_logging: Optional[bool] = None,
                 enable_stackdriver_monitoring: Optional[bool] = None,
                 ip_policy_create_subnetwork: Optional[bool] = None,
                 issue_client_certificate: Optional[bool] = None,
                 kubernetes_dashboard: Optional[bool] = None,
                 local_ssd_count: Optional[float] = None,
                 master_authorized_network_cidr_blocks: Optional[List[str]] = None,
                 max_node_count: Optional[float] = None,
                 min_node_count: Optional[float] = None,
                 node_count: Optional[float] = None,
                 preemptible: Optional[bool] = None,
                 region: Optional[str] = None,
                 taints: Optional[List[str]] = None,
                 use_ip_aliases: Optional[bool] = None,
                 zone: Optional[str] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param str description: (Computed) The description for Cluster (string)
        """
        pulumi.set(__self__, "cluster_ipv4_cidr", cluster_ipv4_cidr)
        pulumi.set(__self__, "credential", credential)
        pulumi.set(__self__, "disk_type", disk_type)
        pulumi.set(__self__, "image_type", image_type)
        pulumi.set(__self__, "ip_policy_cluster_ipv4_cidr_block", ip_policy_cluster_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_cluster_secondary_range_name", ip_policy_cluster_secondary_range_name)
        pulumi.set(__self__, "ip_policy_node_ipv4_cidr_block", ip_policy_node_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_services_ipv4_cidr_block", ip_policy_services_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_services_secondary_range_name", ip_policy_services_secondary_range_name)
        pulumi.set(__self__, "ip_policy_subnetwork_name", ip_policy_subnetwork_name)
        pulumi.set(__self__, "labels", labels)
        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__, "resource_labels", resource_labels)
        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 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 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) -> str:
        return pulumi.get(self, "cluster_ipv4_cidr")

    @property
    @pulumi.getter
    def credential(self) -> str:
        return pulumi.get(self, "credential")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> str:
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> str:
        return pulumi.get(self, "image_type")

    @property
    @pulumi.getter(name="ipPolicyClusterIpv4CidrBlock")
    def ip_policy_cluster_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "ip_policy_cluster_ipv4_cidr_block")

    @property
    @pulumi.getter(name="ipPolicyClusterSecondaryRangeName")
    def ip_policy_cluster_secondary_range_name(self) -> str:
        return pulumi.get(self, "ip_policy_cluster_secondary_range_name")

    @property
    @pulumi.getter(name="ipPolicyNodeIpv4CidrBlock")
    def ip_policy_node_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "ip_policy_node_ipv4_cidr_block")

    @property
    @pulumi.getter(name="ipPolicyServicesIpv4CidrBlock")
    def ip_policy_services_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "ip_policy_services_ipv4_cidr_block")

    @property
    @pulumi.getter(name="ipPolicyServicesSecondaryRangeName")
    def ip_policy_services_secondary_range_name(self) -> str:
        return pulumi.get(self, "ip_policy_services_secondary_range_name")

    @property
    @pulumi.getter(name="ipPolicySubnetworkName")
    def ip_policy_subnetwork_name(self) -> str:
        return pulumi.get(self, "ip_policy_subnetwork_name")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

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

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> str:
        return pulumi.get(self, "maintenance_window")

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "master_ipv4_cidr_block")

    @property
    @pulumi.getter(name="masterVersion")
    def master_version(self) -> str:
        return pulumi.get(self, "master_version")

    @property
    @pulumi.getter
    def network(self) -> str:
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nodePool")
    def node_pool(self) -> str:
        return pulumi.get(self, "node_pool")

    @property
    @pulumi.getter(name="nodeVersion")
    def node_version(self) -> str:
        return pulumi.get(self, "node_version")

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> List[str]:
        return pulumi.get(self, "oauth_scopes")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="resourceLabels")
    def resource_labels(self) -> Mapping[str, Any]:
        return pulumi.get(self, "resource_labels")

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> str:
        return pulumi.get(self, "service_account")

    @property
    @pulumi.getter(name="subNetwork")
    def sub_network(self) -> str:
        return pulumi.get(self, "sub_network")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[bool]:
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @property
    @pulumi.getter(name="enableLegacyAbac")
    def enable_legacy_abac(self) -> Optional[bool]:
        return pulumi.get(self, "enable_legacy_abac")

    @property
    @pulumi.getter(name="enableMasterAuthorizedNetwork")
    def enable_master_authorized_network(self) -> Optional[bool]:
        return pulumi.get(self, "enable_master_authorized_network")

    @property
    @pulumi.getter(name="enableNetworkPolicyConfig")
    def enable_network_policy_config(self) -> Optional[bool]:
        return pulumi.get(self, "enable_network_policy_config")

    @property
    @pulumi.getter(name="enableNodepoolAutoscaling")
    def enable_nodepool_autoscaling(self) -> Optional[bool]:
        return pulumi.get(self, "enable_nodepool_autoscaling")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[bool]:
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[bool]:
        return pulumi.get(self, "enable_private_nodes")

    @property
    @pulumi.getter(name="enableStackdriverLogging")
    def enable_stackdriver_logging(self) -> Optional[bool]:
        return pulumi.get(self, "enable_stackdriver_logging")

    @property
    @pulumi.getter(name="enableStackdriverMonitoring")
    def enable_stackdriver_monitoring(self) -> Optional[bool]:
        return pulumi.get(self, "enable_stackdriver_monitoring")

    @property
    @pulumi.getter(name="ipPolicyCreateSubnetwork")
    def ip_policy_create_subnetwork(self) -> Optional[bool]:
        return pulumi.get(self, "ip_policy_create_subnetwork")

    @property
    @pulumi.getter(name="issueClientCertificate")
    def issue_client_certificate(self) -> Optional[bool]:
        return pulumi.get(self, "issue_client_certificate")

    @property
    @pulumi.getter(name="kubernetesDashboard")
    def kubernetes_dashboard(self) -> Optional[bool]:
        return pulumi.get(self, "kubernetes_dashboard")

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[float]:
        return pulumi.get(self, "local_ssd_count")

    @property
    @pulumi.getter(name="masterAuthorizedNetworkCidrBlocks")
    def master_authorized_network_cidr_blocks(self) -> Optional[List[str]]:
        return pulumi.get(self, "master_authorized_network_cidr_blocks")

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> Optional[float]:
        return pulumi.get(self, "max_node_count")

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[float]:
        return pulumi.get(self, "min_node_count")

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[float]:
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[bool]:
        return pulumi.get(self, "preemptible")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def taints(self) -> Optional[List[str]]:
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[bool]:
        return pulumi.get(self, "use_ip_aliases")

    @property
    @pulumi.getter
    def zone(self) -> Optional[str]:
        return pulumi.get(self, "zone")


@pulumi.output_type
class GetClusterK3sConfigResult(dict):
    def __init__(__self__, *,
                 upgrade_strategy: 'outputs.GetClusterK3sConfigUpgradeStrategyResult',
                 version: str):
        pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterK3sConfigUpgradeStrategyResult':
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter
    def version(self) -> str:
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterK3sConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_server_nodes: Optional[bool] = None,
                 drain_worker_nodes: Optional[bool] = None,
                 server_concurrency: Optional[float] = None,
                 worker_concurrency: Optional[float] = None):
        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[bool]:
        return pulumi.get(self, "drain_server_nodes")

    @property
    @pulumi.getter(name="drainWorkerNodes")
    def drain_worker_nodes(self) -> Optional[bool]:
        return pulumi.get(self, "drain_worker_nodes")

    @property
    @pulumi.getter(name="serverConcurrency")
    def server_concurrency(self) -> Optional[float]:
        return pulumi.get(self, "server_concurrency")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[float]:
        return pulumi.get(self, "worker_concurrency")


@pulumi.output_type
class GetClusterLoggingCustomTargetConfigResult(dict):
    def __init__(__self__, *,
                 content: str,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None):
        pulumi.set(__self__, "content", content)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)

    @property
    @pulumi.getter
    def content(self) -> str:
        return pulumi.get(self, "content")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")


@pulumi.output_type
class GetClusterLoggingElasticsearchConfigResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 ssl_verify: bool,
                 auth_password: Optional[str] = None,
                 auth_username: Optional[str] = None,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 client_key_pass: Optional[str] = None,
                 date_format: Optional[str] = None,
                 index_prefix: Optional[str] = None,
                 ssl_version: Optional[str] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "ssl_verify", ssl_verify)
        if auth_password is not None:
            pulumi.set(__self__, "auth_password", auth_password)
        if auth_username is not None:
            pulumi.set(__self__, "auth_username", auth_username)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if date_format is not None:
            pulumi.set(__self__, "date_format", date_format)
        if index_prefix is not None:
            pulumi.set(__self__, "index_prefix", index_prefix)
        if ssl_version is not None:
            pulumi.set(__self__, "ssl_version", ssl_version)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> bool:
        return pulumi.get(self, "ssl_verify")

    @property
    @pulumi.getter(name="authPassword")
    def auth_password(self) -> Optional[str]:
        return pulumi.get(self, "auth_password")

    @property
    @pulumi.getter(name="authUsername")
    def auth_username(self) -> Optional[str]:
        return pulumi.get(self, "auth_username")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[str]:
        return pulumi.get(self, "client_key_pass")

    @property
    @pulumi.getter(name="dateFormat")
    def date_format(self) -> Optional[str]:
        return pulumi.get(self, "date_format")

    @property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> Optional[str]:
        return pulumi.get(self, "index_prefix")

    @property
    @pulumi.getter(name="sslVersion")
    def ssl_version(self) -> Optional[str]:
        return pulumi.get(self, "ssl_version")


@pulumi.output_type
class GetClusterLoggingFluentdConfigResult(dict):
    def __init__(__self__, *,
                 fluent_servers: List['outputs.GetClusterLoggingFluentdConfigFluentServerResult'],
                 certificate: Optional[str] = None,
                 compress: Optional[bool] = None,
                 enable_tls: Optional[bool] = None):
        pulumi.set(__self__, "fluent_servers", fluent_servers)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)

    @property
    @pulumi.getter(name="fluentServers")
    def fluent_servers(self) -> List['outputs.GetClusterLoggingFluentdConfigFluentServerResult']:
        return pulumi.get(self, "fluent_servers")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def compress(self) -> Optional[bool]:
        return pulumi.get(self, "compress")

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[bool]:
        return pulumi.get(self, "enable_tls")


@pulumi.output_type
class GetClusterLoggingFluentdConfigFluentServerResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 hostname: Optional[str] = None,
                 password: Optional[str] = None,
                 shared_key: Optional[str] = None,
                 standby: Optional[bool] = None,
                 username: Optional[str] = None,
                 weight: Optional[float] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if shared_key is not None:
            pulumi.set(__self__, "shared_key", shared_key)
        if standby is not None:
            pulumi.set(__self__, "standby", standby)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter
    def hostname(self) -> Optional[str]:
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sharedKey")
    def shared_key(self) -> Optional[str]:
        return pulumi.get(self, "shared_key")

    @property
    @pulumi.getter
    def standby(self) -> Optional[bool]:
        return pulumi.get(self, "standby")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def weight(self) -> Optional[float]:
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetClusterLoggingKafkaConfigResult(dict):
    def __init__(__self__, *,
                 topic: str,
                 broker_endpoints: Optional[List[str]] = None,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 zookeeper_endpoint: Optional[str] = None):
        pulumi.set(__self__, "topic", topic)
        if broker_endpoints is not None:
            pulumi.set(__self__, "broker_endpoints", broker_endpoints)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if zookeeper_endpoint is not None:
            pulumi.set(__self__, "zookeeper_endpoint", zookeeper_endpoint)

    @property
    @pulumi.getter
    def topic(self) -> str:
        return pulumi.get(self, "topic")

    @property
    @pulumi.getter(name="brokerEndpoints")
    def broker_endpoints(self) -> Optional[List[str]]:
        return pulumi.get(self, "broker_endpoints")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="zookeeperEndpoint")
    def zookeeper_endpoint(self) -> Optional[str]:
        return pulumi.get(self, "zookeeper_endpoint")


@pulumi.output_type
class GetClusterLoggingSplunkConfigResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 ssl_verify: bool,
                 token: str,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 client_key_pass: Optional[str] = None,
                 index: Optional[str] = None,
                 source: Optional[str] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "ssl_verify", ssl_verify)
        pulumi.set(__self__, "token", token)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if index is not None:
            pulumi.set(__self__, "index", index)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> bool:
        return pulumi.get(self, "ssl_verify")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[str]:
        return pulumi.get(self, "client_key_pass")

    @property
    @pulumi.getter
    def index(self) -> Optional[str]:
        return pulumi.get(self, "index")

    @property
    @pulumi.getter
    def source(self) -> Optional[str]:
        return pulumi.get(self, "source")


@pulumi.output_type
class GetClusterLoggingSyslogConfigResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 ssl_verify: bool,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 enable_tls: Optional[bool] = None,
                 program: Optional[str] = None,
                 protocol: Optional[str] = None,
                 severity: Optional[str] = None,
                 token: Optional[str] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "ssl_verify", ssl_verify)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)
        if program is not None:
            pulumi.set(__self__, "program", program)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> bool:
        return pulumi.get(self, "ssl_verify")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[bool]:
        return pulumi.get(self, "enable_tls")

    @property
    @pulumi.getter
    def program(self) -> Optional[str]:
        return pulumi.get(self, "program")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def severity(self) -> Optional[str]:
        return pulumi.get(self, "severity")

    @property
    @pulumi.getter
    def token(self) -> Optional[str]:
        return pulumi.get(self, "token")


@pulumi.output_type
class GetClusterRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: float,
                 authentication: 'outputs.GetClusterRkeConfigAuthenticationResult',
                 authorization: 'outputs.GetClusterRkeConfigAuthorizationResult',
                 bastion_host: 'outputs.GetClusterRkeConfigBastionHostResult',
                 cloud_provider: 'outputs.GetClusterRkeConfigCloudProviderResult',
                 dns: 'outputs.GetClusterRkeConfigDnsResult',
                 ingress: 'outputs.GetClusterRkeConfigIngressResult',
                 kubernetes_version: str,
                 monitoring: 'outputs.GetClusterRkeConfigMonitoringResult',
                 network: 'outputs.GetClusterRkeConfigNetworkResult',
                 prefix_path: str,
                 services: 'outputs.GetClusterRkeConfigServicesResult',
                 ssh_cert_path: str,
                 ssh_key_path: str,
                 upgrade_strategy: 'outputs.GetClusterRkeConfigUpgradeStrategyResult',
                 addons: Optional[str] = None,
                 addons_includes: Optional[List[str]] = None,
                 ignore_docker_version: Optional[bool] = None,
                 nodes: Optional[List['outputs.GetClusterRkeConfigNodeResult']] = None,
                 private_registries: Optional[List['outputs.GetClusterRkeConfigPrivateRegistryResult']] = None,
                 ssh_agent_auth: Optional[bool] = None):
        pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        pulumi.set(__self__, "authentication", authentication)
        pulumi.set(__self__, "authorization", authorization)
        pulumi.set(__self__, "bastion_host", bastion_host)
        pulumi.set(__self__, "cloud_provider", cloud_provider)
        pulumi.set(__self__, "dns", dns)
        pulumi.set(__self__, "ingress", ingress)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "monitoring", monitoring)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "prefix_path", prefix_path)
        pulumi.set(__self__, "services", services)
        pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)

    @property
    @pulumi.getter(name="addonJobTimeout")
    def addon_job_timeout(self) -> float:
        return pulumi.get(self, "addon_job_timeout")

    @property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetClusterRkeConfigAuthenticationResult':
        return pulumi.get(self, "authentication")

    @property
    @pulumi.getter
    def authorization(self) -> 'outputs.GetClusterRkeConfigAuthorizationResult':
        return pulumi.get(self, "authorization")

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> 'outputs.GetClusterRkeConfigBastionHostResult':
        return pulumi.get(self, "bastion_host")

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> 'outputs.GetClusterRkeConfigCloudProviderResult':
        return pulumi.get(self, "cloud_provider")

    @property
    @pulumi.getter
    def dns(self) -> 'outputs.GetClusterRkeConfigDnsResult':
        return pulumi.get(self, "dns")

    @property
    @pulumi.getter
    def ingress(self) -> 'outputs.GetClusterRkeConfigIngressResult':
        return pulumi.get(self, "ingress")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def monitoring(self) -> 'outputs.GetClusterRkeConfigMonitoringResult':
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterRkeConfigNetworkResult':
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> str:
        return pulumi.get(self, "prefix_path")

    @property
    @pulumi.getter
    def services(self) -> 'outputs.GetClusterRkeConfigServicesResult':
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> str:
        return pulumi.get(self, "ssh_cert_path")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterRkeConfigUpgradeStrategyResult':
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter
    def addons(self) -> Optional[str]:
        return pulumi.get(self, "addons")

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[List[str]]:
        return pulumi.get(self, "addons_includes")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_docker_version")

    @property
    @pulumi.getter
    def nodes(self) -> Optional[List['outputs.GetClusterRkeConfigNodeResult']]:
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[List['outputs.GetClusterRkeConfigPrivateRegistryResult']]:
        return pulumi.get(self, "private_registries")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigAuthenticationResult(dict):
    def __init__(__self__, *,
                 sans: List[str],
                 strategy: str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> List[str]:
        return pulumi.get(self, "sans")

    @property
    @pulumi.getter
    def strategy(self) -> str:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigAuthorizationResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 mode: Optional[str] = None):
        pulumi.set(__self__, "options", options)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetClusterRkeConfigBastionHostResult(dict):
    def __init__(__self__, *,
                 address: str,
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        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)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderResult(dict):
    def __init__(__self__, *,
                 custom_cloud_provider: str,
                 name: str,
                 aws_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 openstack_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult'] = None,
                 vsphere_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderResult'] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        pulumi.set(__self__, "name", name)
        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 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="customCloudProvider")
    def custom_cloud_provider(self) -> str:
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderResult']:
        return pulumi.get(self, "aws_cloud_provider")

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderAzureCloudProviderResult']:
        return pulumi.get(self, "azure_cloud_provider")

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult']:
        return pulumi.get(self, "openstack_cloud_provider")

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderResult']:
        return pulumi.get(self, "vsphere_cloud_provider")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderResult(dict):
    def __init__(__self__, *,
                 global_: 'outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult',
                 service_overrides: Optional[List['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']] = 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) -> 'outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[List['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']]:
        return pulumi.get(self, "service_overrides")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 elb_security_group: str,
                 kubernetes_cluster_id: str,
                 kubernetes_cluster_tag: str,
                 role_arn: str,
                 route_table_id: str,
                 subnet_id: str,
                 vpc: str,
                 zone: str,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None):
        pulumi.set(__self__, "elb_security_group", elb_security_group)
        pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc", vpc)
        pulumi.set(__self__, "zone", zone)
        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)

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> str:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> str:
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[bool]:
        return pulumi.get(self, "disable_strict_zone_check")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult(dict):
    def __init__(__self__, *,
                 region: str,
                 service: str,
                 signing_method: str,
                 signing_name: str,
                 signing_region: str,
                 url: str):
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "signing_method", signing_method)
        pulumi.set(__self__, "signing_name", signing_name)
        pulumi.set(__self__, "signing_region", signing_region)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> str:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> str:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> str:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAzureCloudProviderResult(dict):
    def __init__(__self__, *,
                 aad_client_cert_password: str,
                 aad_client_cert_path: str,
                 aad_client_id: str,
                 aad_client_secret: str,
                 cloud: str,
                 cloud_provider_backoff: bool,
                 cloud_provider_backoff_duration: float,
                 cloud_provider_backoff_exponent: float,
                 cloud_provider_backoff_jitter: float,
                 cloud_provider_backoff_retries: float,
                 cloud_provider_rate_limit: bool,
                 cloud_provider_rate_limit_bucket: float,
                 cloud_provider_rate_limit_qps: float,
                 location: str,
                 maximum_load_balancer_rule_count: float,
                 primary_availability_set_name: str,
                 primary_scale_set_name: str,
                 resource_group: str,
                 route_table_name: str,
                 security_group_name: str,
                 subnet_name: str,
                 subscription_id: str,
                 tenant_id: str,
                 use_instance_metadata: bool,
                 use_managed_identity_extension: bool,
                 vm_type: str,
                 vnet_name: str,
                 vnet_resource_group: str,
                 load_balancer_sku: Optional[str] = None):
        pulumi.set(__self__, "aad_client_cert_password", aad_client_cert_password)
        pulumi.set(__self__, "aad_client_cert_path", aad_client_cert_path)
        pulumi.set(__self__, "aad_client_id", aad_client_id)
        pulumi.set(__self__, "aad_client_secret", aad_client_secret)
        pulumi.set(__self__, "cloud", cloud)
        pulumi.set(__self__, "cloud_provider_backoff", cloud_provider_backoff)
        pulumi.set(__self__, "cloud_provider_backoff_duration", cloud_provider_backoff_duration)
        pulumi.set(__self__, "cloud_provider_backoff_exponent", cloud_provider_backoff_exponent)
        pulumi.set(__self__, "cloud_provider_backoff_jitter", cloud_provider_backoff_jitter)
        pulumi.set(__self__, "cloud_provider_backoff_retries", cloud_provider_backoff_retries)
        pulumi.set(__self__, "cloud_provider_rate_limit", cloud_provider_rate_limit)
        pulumi.set(__self__, "cloud_provider_rate_limit_bucket", cloud_provider_rate_limit_bucket)
        pulumi.set(__self__, "cloud_provider_rate_limit_qps", cloud_provider_rate_limit_qps)
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "maximum_load_balancer_rule_count", maximum_load_balancer_rule_count)
        pulumi.set(__self__, "primary_availability_set_name", primary_availability_set_name)
        pulumi.set(__self__, "primary_scale_set_name", primary_scale_set_name)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "route_table_name", route_table_name)
        pulumi.set(__self__, "security_group_name", security_group_name)
        pulumi.set(__self__, "subnet_name", subnet_name)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "use_instance_metadata", use_instance_metadata)
        pulumi.set(__self__, "use_managed_identity_extension", use_managed_identity_extension)
        pulumi.set(__self__, "vm_type", vm_type)
        pulumi.set(__self__, "vnet_name", vnet_name)
        pulumi.set(__self__, "vnet_resource_group", vnet_resource_group)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)

    @property
    @pulumi.getter(name="aadClientCertPassword")
    def aad_client_cert_password(self) -> str:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> str:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter
    def cloud(self) -> str:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> bool:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> bool:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> float:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> float:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter
    def location(self) -> str:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> float:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> str:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> str:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> str:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> str:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> str:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> bool:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> bool:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> str:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> str:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> str:
        return pulumi.get(self, "vnet_resource_group")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        return pulumi.get(self, "load_balancer_sku")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult(dict):
    def __init__(__self__, *,
                 block_storage: 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult',
                 global_: 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult',
                 load_balancer: 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult',
                 metadata: 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult',
                 route: 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult'):
        pulumi.set(__self__, "block_storage", block_storage)
        pulumi.set(__self__, "global_", global_)
        pulumi.set(__self__, "load_balancer", load_balancer)
        pulumi.set(__self__, "metadata", metadata)
        pulumi.set(__self__, "route", route)

    @property
    @pulumi.getter(name="blockStorage")
    def block_storage(self) -> 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult':
        return pulumi.get(self, "block_storage")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="loadBalancer")
    def load_balancer(self) -> 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult':
        return pulumi.get(self, "load_balancer")

    @property
    @pulumi.getter
    def metadata(self) -> 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult':
        return pulumi.get(self, "metadata")

    @property
    @pulumi.getter
    def route(self) -> 'outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult':
        return pulumi.get(self, "route")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult(dict):
    def __init__(__self__, *,
                 bs_version: str,
                 ignore_volume_az: bool,
                 trust_device_path: bool):
        pulumi.set(__self__, "bs_version", bs_version)
        pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> str:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> bool:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> bool:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 auth_url: str,
                 ca_file: str,
                 domain_id: str,
                 domain_name: str,
                 password: str,
                 region: str,
                 tenant_id: str,
                 tenant_name: str,
                 trust_id: str,
                 username: str):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "ca_file", ca_file)
        pulumi.set(__self__, "domain_id", domain_id)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "tenant_name", tenant_name)
        pulumi.set(__self__, "trust_id", trust_id)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> str:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> str:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> str:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> str:
        return pulumi.get(self, "trust_id")

    @property
    @pulumi.getter
    def username(self) -> str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult(dict):
    def __init__(__self__, *,
                 create_monitor: bool,
                 floating_network_id: str,
                 lb_method: str,
                 lb_provider: str,
                 lb_version: str,
                 manage_security_groups: bool,
                 subnet_id: str,
                 use_octavia: bool,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[float] = None,
                 monitor_timeout: Optional[str] = None):
        pulumi.set(__self__, "create_monitor", create_monitor)
        pulumi.set(__self__, "floating_network_id", floating_network_id)
        pulumi.set(__self__, "lb_method", lb_method)
        pulumi.set(__self__, "lb_provider", lb_provider)
        pulumi.set(__self__, "lb_version", lb_version)
        pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "use_octavia", use_octavia)
        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)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> bool:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> str:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> str:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> str:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> str:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> bool:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> bool:
        return pulumi.get(self, "use_octavia")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[float]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[str]:
        return pulumi.get(self, "monitor_timeout")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult(dict):
    def __init__(__self__, *,
                 request_timeout: float,
                 search_order: str):
        pulumi.set(__self__, "request_timeout", request_timeout)
        pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> float:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> str:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult(dict):
    def __init__(__self__, *,
                 router_id: str):
        pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        return pulumi.get(self, "router_id")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderResult(dict):
    def __init__(__self__, *,
                 disk: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult',
                 global_: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
                 network: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
                 virtual_centers: List['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult'],
                 workspace: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult'):
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "global_", global_)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)

    @property
    @pulumi.getter
    def disk(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult':
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult':
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> List['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult']:
        return pulumi.get(self, "virtual_centers")

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult':
        return pulumi.get(self, "workspace")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult(dict):
    def __init__(__self__, *,
                 scsi_controller_type: str):
        pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> str:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 insecure_flag: bool,
                 password: str,
                 port: str,
                 soap_roundtrip_count: float,
                 user: str):
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "insecure_flag", insecure_flag)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> bool:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> float:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult(dict):
    def __init__(__self__, *,
                 public_network: str):
        pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> str:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 port: str,
                 soap_roundtrip_count: float,
                 user: str):
        """
        :param 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__, "port", port)
        pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> float:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult(dict):
    def __init__(__self__, *,
                 datacenter: str,
                 default_datastore: str,
                 folder: str,
                 resourcepool_path: str,
                 server: str):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "default_datastore", default_datastore)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "resourcepool_path", resourcepool_path)
        pulumi.set(__self__, "server", server)

    @property
    @pulumi.getter
    def datacenter(self) -> str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> str:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter
    def folder(self) -> str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> str:
        return pulumi.get(self, "resourcepool_path")

    @property
    @pulumi.getter
    def server(self) -> str:
        return pulumi.get(self, "server")


@pulumi.output_type
class GetClusterRkeConfigDnsResult(dict):
    def __init__(__self__, *,
                 node_selector: Mapping[str, Any],
                 reverse_cidrs: List[str],
                 upstream_nameservers: List[str],
                 nodelocal: Optional['outputs.GetClusterRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[str] = None):
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> List[str]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> List[str]:
        return pulumi.get(self, "upstream_nameservers")

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional['outputs.GetClusterRkeConfigDnsNodelocalResult']:
        return pulumi.get(self, "nodelocal")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        return pulumi.get(self, "provider")


@pulumi.output_type
class GetClusterRkeConfigDnsNodelocalResult(dict):
    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class GetClusterRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: str,
                 extra_args: Mapping[str, Any],
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 provider: str):
        pulumi.set(__self__, "dns_policy", dns_policy)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> str:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")


@pulumi.output_type
class GetClusterRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 provider: str,
                 replicas: float,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyResult'] = None):
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "provider", provider)
        pulumi.set(__self__, "replicas", replicas)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> float:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterRkeConfigMonitoringUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[str]:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[float] = None,
                 max_unavailable: Optional[float] = None):
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[float]:
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[float]:
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigNetworkResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 plugin: str,
                 calico_network_provider: Optional['outputs.GetClusterRkeConfigNetworkCalicoNetworkProviderResult'] = None,
                 canal_network_provider: Optional['outputs.GetClusterRkeConfigNetworkCanalNetworkProviderResult'] = None,
                 flannel_network_provider: Optional['outputs.GetClusterRkeConfigNetworkFlannelNetworkProviderResult'] = None,
                 mtu: Optional[float] = None,
                 weave_network_provider: Optional['outputs.GetClusterRkeConfigNetworkWeaveNetworkProviderResult'] = None):
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "plugin", plugin)
        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 weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> str:
        return pulumi.get(self, "plugin")

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional['outputs.GetClusterRkeConfigNetworkCalicoNetworkProviderResult']:
        return pulumi.get(self, "calico_network_provider")

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional['outputs.GetClusterRkeConfigNetworkCanalNetworkProviderResult']:
        return pulumi.get(self, "canal_network_provider")

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional['outputs.GetClusterRkeConfigNetworkFlannelNetworkProviderResult']:
        return pulumi.get(self, "flannel_network_provider")

    @property
    @pulumi.getter
    def mtu(self) -> Optional[float]:
        return pulumi.get(self, "mtu")

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional['outputs.GetClusterRkeConfigNetworkWeaveNetworkProviderResult']:
        return pulumi.get(self, "weave_network_provider")


@pulumi.output_type
class GetClusterRkeConfigNetworkCalicoNetworkProviderResult(dict):
    def __init__(__self__, *,
                 cloud_provider: str):
        pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> str:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class GetClusterRkeConfigNetworkCanalNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterRkeConfigNetworkFlannelNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterRkeConfigNetworkWeaveNetworkProviderResult(dict):
    def __init__(__self__, *,
                 password: str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")


@pulumi.output_type
class GetClusterRkeConfigNodeResult(dict):
    def __init__(__self__, *,
                 address: str,
                 docker_socket: str,
                 roles: List[str],
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "docker_socket", docker_socket)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "user", user)
        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)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> str:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter
    def roles(self) -> List[str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigPrivateRegistryResult(dict):
    def __init__(__self__, *,
                 url: str,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigServicesResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterRkeConfigServicesEtcdResult',
                 kube_api: 'outputs.GetClusterRkeConfigServicesKubeApiResult',
                 kube_controller: 'outputs.GetClusterRkeConfigServicesKubeControllerResult',
                 kubelet: 'outputs.GetClusterRkeConfigServicesKubeletResult',
                 kubeproxy: 'outputs.GetClusterRkeConfigServicesKubeproxyResult',
                 scheduler: 'outputs.GetClusterRkeConfigServicesSchedulerResult'):
        pulumi.set(__self__, "etcd", etcd)
        pulumi.set(__self__, "kube_api", kube_api)
        pulumi.set(__self__, "kube_controller", kube_controller)
        pulumi.set(__self__, "kubelet", kubelet)
        pulumi.set(__self__, "kubeproxy", kubeproxy)
        pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> 'outputs.GetClusterRkeConfigServicesEtcdResult':
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> 'outputs.GetClusterRkeConfigServicesKubeApiResult':
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> 'outputs.GetClusterRkeConfigServicesKubeControllerResult':
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> 'outputs.GetClusterRkeConfigServicesKubeletResult':
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> 'outputs.GetClusterRkeConfigServicesKubeproxyResult':
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> 'outputs.GetClusterRkeConfigServicesSchedulerResult':
        return pulumi.get(self, "scheduler")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdResult(dict):
    def __init__(__self__, *,
                 backup_config: 'outputs.GetClusterRkeConfigServicesEtcdBackupConfigResult',
                 ca_cert: str,
                 cert: str,
                 creation: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 key: str,
                 path: str,
                 retention: str,
                 snapshot: bool,
                 external_urls: Optional[List[str]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 gid: Optional[float] = None,
                 uid: Optional[float] = None):
        pulumi.set(__self__, "backup_config", backup_config)
        pulumi.set(__self__, "ca_cert", ca_cert)
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "creation", creation)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "retention", retention)
        pulumi.set(__self__, "snapshot", snapshot)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        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 uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> 'outputs.GetClusterRkeConfigServicesEtcdBackupConfigResult':
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> str:
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> str:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> str:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> bool:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[List[str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[float]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def uid(self) -> Optional[float]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[float] = None,
                 retention: Optional[float] = None,
                 s3_backup_config: Optional['outputs.GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = 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)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[float]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[float]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[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) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 service_node_port_range: str,
                 admission_configuration: Optional[Mapping[str, Any]] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.GetClusterRkeConfigServicesKubeApiAuditLogResult'] = None,
                 event_rate_limit: Optional['outputs.GetClusterRkeConfigServicesKubeApiEventRateLimitResult'] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult'] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        pulumi.set(__self__, "service_node_port_range", service_node_port_range)
        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_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 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)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> str:
        return pulumi.get(self, "service_node_port_range")

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[bool]:
        return pulumi.get(self, "always_pull_images")

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiAuditLogResult']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiEventRateLimitResult']:
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[bool]:
        return pulumi.get(self, "pod_security_policy")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult']:
        return pulumi.get(self, "secrets_encryption_config")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAuditLogResult(dict):
    def __init__(__self__, *,
                 configuration: 'outputs.GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult',
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> 'outputs.GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult':
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult(dict):
    def __init__(__self__, *,
                 policy: str,
                 format: Optional[str] = None,
                 max_age: Optional[float] = None,
                 max_backup: Optional[float] = None,
                 max_size: Optional[float] = None,
                 path: Optional[str] = None):
        pulumi.set(__self__, "policy", policy)
        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)

    @property
    @pulumi.getter
    def policy(self) -> str:
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[float]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[float]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[float]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiEventRateLimitResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeControllerResult(dict):
    def __init__(__self__, *,
                 cluster_cidr: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None):
        pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        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)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> str:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeletResult(dict):
    def __init__(__self__, *,
                 cluster_dns_server: str,
                 cluster_domain: str,
                 extra_args: Mapping[str, Any],
                 fail_swap_on: bool,
                 image: str,
                 infra_container_image: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 generate_serving_certificate: Optional[bool] = None):
        pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        pulumi.set(__self__, "cluster_domain", cluster_domain)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "infra_container_image", infra_container_image)
        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 generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> str:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> str:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> bool:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> str:
        return pulumi.get(self, "infra_container_image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[bool]:
        return pulumi.get(self, "generate_serving_certificate")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeproxyResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        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)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigServicesSchedulerResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        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)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_input: 'outputs.GetClusterRkeConfigUpgradeStrategyDrainInputResult',
                 drain: Optional[bool] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        pulumi.set(__self__, "drain_input", drain_input)
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        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(name="drainInput")
    def drain_input(self) -> 'outputs.GetClusterRkeConfigUpgradeStrategyDrainInputResult':
        return pulumi.get(self, "drain_input")

    @property
    @pulumi.getter
    def drain(self) -> Optional[bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class GetClusterRkeConfigUpgradeStrategyDrainInputResult(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[float] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[float] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[float]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[float]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetClusterScanScanConfigResult(dict):
    def __init__(__self__, *,
                 cis_scan_config: 'outputs.GetClusterScanScanConfigCisScanConfigResult'):
        """
        :param 'GetClusterScanScanConfigCisScanConfigArgs' cis_scan_config: Cluster Cis Scan config (List maxitems:1)
        """
        pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> 'outputs.GetClusterScanScanConfigCisScanConfigResult':
        """
        Cluster Cis Scan config (List maxitems:1)
        """
        return pulumi.get(self, "cis_scan_config")


@pulumi.output_type
class GetClusterScanScanConfigCisScanConfigResult(dict):
    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[List[str]] = None,
                 profile: Optional[str] = None):
        """
        :param bool debug_master: Debug master. Default: `false` (bool)
        :param bool debug_worker: Debug worker. Default: `false` (bool)
        :param str override_benchmark_version: Override benchmark version (string)
        :param List[str] override_skips: Override skip (string)
        :param str profile: Cis scan profile. Allowed values: `"permissive" (default) || "hardened"` (string)
        """
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="debugMaster")
    def debug_master(self) -> Optional[bool]:
        """
        Debug master. Default: `false` (bool)
        """
        return pulumi.get(self, "debug_master")

    @property
    @pulumi.getter(name="debugWorker")
    def debug_worker(self) -> Optional[bool]:
        """
        Debug worker. Default: `false` (bool)
        """
        return pulumi.get(self, "debug_worker")

    @property
    @pulumi.getter(name="overrideBenchmarkVersion")
    def override_benchmark_version(self) -> Optional[str]:
        """
        Override benchmark version (string)
        """
        return pulumi.get(self, "override_benchmark_version")

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[List[str]]:
        """
        Override skip (string)
        """
        return pulumi.get(self, "override_skips")

    @property
    @pulumi.getter
    def profile(self) -> Optional[str]:
        """
        Cis scan profile. Allowed values: `"permissive" (default) || "hardened"` (string)
        """
        return pulumi.get(self, "profile")


@pulumi.output_type
class GetClusterScheduledClusterScanResult(dict):
    def __init__(__self__, *,
                 scan_config: 'outputs.GetClusterScheduledClusterScanScanConfigResult',
                 schedule_config: 'outputs.GetClusterScheduledClusterScanScheduleConfigResult',
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "scan_config", scan_config)
        pulumi.set(__self__, "schedule_config", schedule_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="scanConfig")
    def scan_config(self) -> 'outputs.GetClusterScheduledClusterScanScanConfigResult':
        return pulumi.get(self, "scan_config")

    @property
    @pulumi.getter(name="scheduleConfig")
    def schedule_config(self) -> 'outputs.GetClusterScheduledClusterScanScheduleConfigResult':
        return pulumi.get(self, "schedule_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterScheduledClusterScanScanConfigResult(dict):
    def __init__(__self__, *,
                 cis_scan_config: 'outputs.GetClusterScheduledClusterScanScanConfigCisScanConfigResult'):
        pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> 'outputs.GetClusterScheduledClusterScanScanConfigCisScanConfigResult':
        return pulumi.get(self, "cis_scan_config")


@pulumi.output_type
class GetClusterScheduledClusterScanScanConfigCisScanConfigResult(dict):
    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[List[str]] = None,
                 profile: Optional[str] = None):
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="debugMaster")
    def debug_master(self) -> Optional[bool]:
        return pulumi.get(self, "debug_master")

    @property
    @pulumi.getter(name="debugWorker")
    def debug_worker(self) -> Optional[bool]:
        return pulumi.get(self, "debug_worker")

    @property
    @pulumi.getter(name="overrideBenchmarkVersion")
    def override_benchmark_version(self) -> Optional[str]:
        return pulumi.get(self, "override_benchmark_version")

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[List[str]]:
        return pulumi.get(self, "override_skips")

    @property
    @pulumi.getter
    def profile(self) -> Optional[str]:
        return pulumi.get(self, "profile")


@pulumi.output_type
class GetClusterScheduledClusterScanScheduleConfigResult(dict):
    def __init__(__self__, *,
                 cron_schedule: str,
                 retention: float):
        pulumi.set(__self__, "cron_schedule", cron_schedule)
        pulumi.set(__self__, "retention", retention)

    @property
    @pulumi.getter(name="cronSchedule")
    def cron_schedule(self) -> str:
        return pulumi.get(self, "cron_schedule")

    @property
    @pulumi.getter
    def retention(self) -> float:
        return pulumi.get(self, "retention")


@pulumi.output_type
class GetClusterTemplateMemberResult(dict):
    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        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[str]:
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[str]:
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        return pulumi.get(self, "user_principal_id")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cluster_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigResult',
                 cluster_template_id: str,
                 id: str,
                 labels: Mapping[str, Any],
                 name: str,
                 default: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 questions: Optional[List['outputs.GetClusterTemplateTemplateRevisionQuestionResult']] = None):
        """
        :param Mapping[str, Any] annotations: (Computed) Annotations for the cluster template (map)
        :param str id: (Computed) The ID of the resource (string)
        :param Mapping[str, Any] labels: (Computed) Labels for the cluster template (map)
        :param str name: The cluster template name (string)
        """
        pulumi.set(__self__, "annotations", annotations)
        pulumi.set(__self__, "cluster_config", cluster_config)
        pulumi.set(__self__, "cluster_template_id", cluster_template_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "name", name)
        if default is not None:
            pulumi.set(__self__, "default", default)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if questions is not None:
            pulumi.set(__self__, "questions", questions)

    @property
    @pulumi.getter
    def annotations(self) -> Mapping[str, Any]:
        """
        (Computed) Annotations for the cluster template (map)
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterConfig")
    def cluster_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigResult':
        return pulumi.get(self, "cluster_config")

    @property
    @pulumi.getter(name="clusterTemplateId")
    def cluster_template_id(self) -> str:
        return pulumi.get(self, "cluster_template_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def default(self) -> Optional[bool]:
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def questions(self) -> Optional[List['outputs.GetClusterTemplateTemplateRevisionQuestionResult']]:
        return pulumi.get(self, "questions")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigResult(dict):
    def __init__(__self__, *,
                 cluster_auth_endpoint: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult',
                 default_cluster_role_for_project_members: str,
                 default_pod_security_policy_template_id: str,
                 desired_agent_image: str,
                 desired_auth_image: str,
                 docker_root_dir: str,
                 rke_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult',
                 enable_cluster_alerting: Optional[bool] = None,
                 enable_cluster_monitoring: Optional[bool] = None,
                 enable_network_policy: Optional[bool] = None,
                 scheduled_cluster_scan: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanResult'] = None,
                 windows_prefered_cluster: Optional[bool] = None):
        pulumi.set(__self__, "cluster_auth_endpoint", cluster_auth_endpoint)
        pulumi.set(__self__, "default_cluster_role_for_project_members", default_cluster_role_for_project_members)
        pulumi.set(__self__, "default_pod_security_policy_template_id", default_pod_security_policy_template_id)
        pulumi.set(__self__, "desired_agent_image", desired_agent_image)
        pulumi.set(__self__, "desired_auth_image", desired_auth_image)
        pulumi.set(__self__, "docker_root_dir", docker_root_dir)
        pulumi.set(__self__, "rke_config", rke_config)
        if enable_cluster_alerting is not None:
            pulumi.set(__self__, "enable_cluster_alerting", enable_cluster_alerting)
        if enable_cluster_monitoring is not None:
            pulumi.set(__self__, "enable_cluster_monitoring", enable_cluster_monitoring)
        if enable_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if scheduled_cluster_scan is not None:
            pulumi.set(__self__, "scheduled_cluster_scan", scheduled_cluster_scan)
        if windows_prefered_cluster is not None:
            pulumi.set(__self__, "windows_prefered_cluster", windows_prefered_cluster)

    @property
    @pulumi.getter(name="clusterAuthEndpoint")
    def cluster_auth_endpoint(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult':
        return pulumi.get(self, "cluster_auth_endpoint")

    @property
    @pulumi.getter(name="defaultClusterRoleForProjectMembers")
    def default_cluster_role_for_project_members(self) -> str:
        return pulumi.get(self, "default_cluster_role_for_project_members")

    @property
    @pulumi.getter(name="defaultPodSecurityPolicyTemplateId")
    def default_pod_security_policy_template_id(self) -> str:
        return pulumi.get(self, "default_pod_security_policy_template_id")

    @property
    @pulumi.getter(name="desiredAgentImage")
    def desired_agent_image(self) -> str:
        return pulumi.get(self, "desired_agent_image")

    @property
    @pulumi.getter(name="desiredAuthImage")
    def desired_auth_image(self) -> str:
        return pulumi.get(self, "desired_auth_image")

    @property
    @pulumi.getter(name="dockerRootDir")
    def docker_root_dir(self) -> str:
        return pulumi.get(self, "docker_root_dir")

    @property
    @pulumi.getter(name="rkeConfig")
    def rke_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult':
        return pulumi.get(self, "rke_config")

    @property
    @pulumi.getter(name="enableClusterAlerting")
    def enable_cluster_alerting(self) -> Optional[bool]:
        return pulumi.get(self, "enable_cluster_alerting")

    @property
    @pulumi.getter(name="enableClusterMonitoring")
    def enable_cluster_monitoring(self) -> Optional[bool]:
        return pulumi.get(self, "enable_cluster_monitoring")

    @property
    @pulumi.getter(name="enableNetworkPolicy")
    def enable_network_policy(self) -> Optional[bool]:
        return pulumi.get(self, "enable_network_policy")

    @property
    @pulumi.getter(name="scheduledClusterScan")
    def scheduled_cluster_scan(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanResult']:
        return pulumi.get(self, "scheduled_cluster_scan")

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[bool]:
        return pulumi.get(self, "windows_prefered_cluster")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[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[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: float,
                 authentication: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult',
                 authorization: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult',
                 bastion_host: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult',
                 cloud_provider: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult',
                 dns: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult',
                 ingress: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult',
                 kubernetes_version: str,
                 monitoring: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult',
                 network: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult',
                 prefix_path: str,
                 services: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult',
                 ssh_cert_path: str,
                 ssh_key_path: str,
                 upgrade_strategy: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult',
                 addons: Optional[str] = None,
                 addons_includes: Optional[List[str]] = None,
                 ignore_docker_version: Optional[bool] = None,
                 nodes: Optional[List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']] = None,
                 private_registries: Optional[List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult']] = None,
                 ssh_agent_auth: Optional[bool] = None):
        pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        pulumi.set(__self__, "authentication", authentication)
        pulumi.set(__self__, "authorization", authorization)
        pulumi.set(__self__, "bastion_host", bastion_host)
        pulumi.set(__self__, "cloud_provider", cloud_provider)
        pulumi.set(__self__, "dns", dns)
        pulumi.set(__self__, "ingress", ingress)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "monitoring", monitoring)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "prefix_path", prefix_path)
        pulumi.set(__self__, "services", services)
        pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)

    @property
    @pulumi.getter(name="addonJobTimeout")
    def addon_job_timeout(self) -> float:
        return pulumi.get(self, "addon_job_timeout")

    @property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult':
        return pulumi.get(self, "authentication")

    @property
    @pulumi.getter
    def authorization(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult':
        return pulumi.get(self, "authorization")

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult':
        return pulumi.get(self, "bastion_host")

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult':
        return pulumi.get(self, "cloud_provider")

    @property
    @pulumi.getter
    def dns(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult':
        return pulumi.get(self, "dns")

    @property
    @pulumi.getter
    def ingress(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult':
        return pulumi.get(self, "ingress")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def monitoring(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult':
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult':
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> str:
        return pulumi.get(self, "prefix_path")

    @property
    @pulumi.getter
    def services(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult':
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> str:
        return pulumi.get(self, "ssh_cert_path")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult':
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter
    def addons(self) -> Optional[str]:
        return pulumi.get(self, "addons")

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[List[str]]:
        return pulumi.get(self, "addons_includes")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_docker_version")

    @property
    @pulumi.getter
    def nodes(self) -> Optional[List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']]:
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult']]:
        return pulumi.get(self, "private_registries")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult(dict):
    def __init__(__self__, *,
                 sans: List[str],
                 strategy: str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> List[str]:
        return pulumi.get(self, "sans")

    @property
    @pulumi.getter
    def strategy(self) -> str:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 mode: Optional[str] = None):
        pulumi.set(__self__, "options", options)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult(dict):
    def __init__(__self__, *,
                 address: str,
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        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)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult(dict):
    def __init__(__self__, *,
                 custom_cloud_provider: str,
                 name: str,
                 aws_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 openstack_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult'] = None,
                 vsphere_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult'] = None):
        """
        :param str name: The cluster template name (string)
        """
        pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        pulumi.set(__self__, "name", name)
        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 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="customCloudProvider")
    def custom_cloud_provider(self) -> str:
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult']:
        return pulumi.get(self, "aws_cloud_provider")

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult']:
        return pulumi.get(self, "azure_cloud_provider")

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult']:
        return pulumi.get(self, "openstack_cloud_provider")

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult']:
        return pulumi.get(self, "vsphere_cloud_provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult(dict):
    def __init__(__self__, *,
                 global_: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult',
                 service_overrides: Optional[List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']] = 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) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']]:
        return pulumi.get(self, "service_overrides")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 elb_security_group: str,
                 kubernetes_cluster_id: str,
                 kubernetes_cluster_tag: str,
                 role_arn: str,
                 route_table_id: str,
                 subnet_id: str,
                 vpc: str,
                 zone: str,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None):
        pulumi.set(__self__, "elb_security_group", elb_security_group)
        pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc", vpc)
        pulumi.set(__self__, "zone", zone)
        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)

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> str:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> str:
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[bool]:
        return pulumi.get(self, "disable_strict_zone_check")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult(dict):
    def __init__(__self__, *,
                 region: str,
                 service: str,
                 signing_method: str,
                 signing_name: str,
                 signing_region: str,
                 url: str):
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "signing_method", signing_method)
        pulumi.set(__self__, "signing_name", signing_name)
        pulumi.set(__self__, "signing_region", signing_region)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> str:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> str:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> str:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult(dict):
    def __init__(__self__, *,
                 aad_client_cert_password: str,
                 aad_client_cert_path: str,
                 aad_client_id: str,
                 aad_client_secret: str,
                 cloud: str,
                 cloud_provider_backoff: bool,
                 cloud_provider_backoff_duration: float,
                 cloud_provider_backoff_exponent: float,
                 cloud_provider_backoff_jitter: float,
                 cloud_provider_backoff_retries: float,
                 cloud_provider_rate_limit: bool,
                 cloud_provider_rate_limit_bucket: float,
                 cloud_provider_rate_limit_qps: float,
                 location: str,
                 maximum_load_balancer_rule_count: float,
                 primary_availability_set_name: str,
                 primary_scale_set_name: str,
                 resource_group: str,
                 route_table_name: str,
                 security_group_name: str,
                 subnet_name: str,
                 subscription_id: str,
                 tenant_id: str,
                 use_instance_metadata: bool,
                 use_managed_identity_extension: bool,
                 vm_type: str,
                 vnet_name: str,
                 vnet_resource_group: str,
                 load_balancer_sku: Optional[str] = None):
        pulumi.set(__self__, "aad_client_cert_password", aad_client_cert_password)
        pulumi.set(__self__, "aad_client_cert_path", aad_client_cert_path)
        pulumi.set(__self__, "aad_client_id", aad_client_id)
        pulumi.set(__self__, "aad_client_secret", aad_client_secret)
        pulumi.set(__self__, "cloud", cloud)
        pulumi.set(__self__, "cloud_provider_backoff", cloud_provider_backoff)
        pulumi.set(__self__, "cloud_provider_backoff_duration", cloud_provider_backoff_duration)
        pulumi.set(__self__, "cloud_provider_backoff_exponent", cloud_provider_backoff_exponent)
        pulumi.set(__self__, "cloud_provider_backoff_jitter", cloud_provider_backoff_jitter)
        pulumi.set(__self__, "cloud_provider_backoff_retries", cloud_provider_backoff_retries)
        pulumi.set(__self__, "cloud_provider_rate_limit", cloud_provider_rate_limit)
        pulumi.set(__self__, "cloud_provider_rate_limit_bucket", cloud_provider_rate_limit_bucket)
        pulumi.set(__self__, "cloud_provider_rate_limit_qps", cloud_provider_rate_limit_qps)
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "maximum_load_balancer_rule_count", maximum_load_balancer_rule_count)
        pulumi.set(__self__, "primary_availability_set_name", primary_availability_set_name)
        pulumi.set(__self__, "primary_scale_set_name", primary_scale_set_name)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "route_table_name", route_table_name)
        pulumi.set(__self__, "security_group_name", security_group_name)
        pulumi.set(__self__, "subnet_name", subnet_name)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "use_instance_metadata", use_instance_metadata)
        pulumi.set(__self__, "use_managed_identity_extension", use_managed_identity_extension)
        pulumi.set(__self__, "vm_type", vm_type)
        pulumi.set(__self__, "vnet_name", vnet_name)
        pulumi.set(__self__, "vnet_resource_group", vnet_resource_group)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)

    @property
    @pulumi.getter(name="aadClientCertPassword")
    def aad_client_cert_password(self) -> str:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> str:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter
    def cloud(self) -> str:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> bool:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> float:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> bool:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> float:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> float:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter
    def location(self) -> str:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> float:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> str:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> str:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> str:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> str:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> str:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> bool:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> bool:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> str:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> str:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> str:
        return pulumi.get(self, "vnet_resource_group")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        return pulumi.get(self, "load_balancer_sku")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult(dict):
    def __init__(__self__, *,
                 block_storage: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult',
                 global_: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalResult',
                 load_balancer: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult',
                 metadata: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataResult',
                 route: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteResult'):
        pulumi.set(__self__, "block_storage", block_storage)
        pulumi.set(__self__, "global_", global_)
        pulumi.set(__self__, "load_balancer", load_balancer)
        pulumi.set(__self__, "metadata", metadata)
        pulumi.set(__self__, "route", route)

    @property
    @pulumi.getter(name="blockStorage")
    def block_storage(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult':
        return pulumi.get(self, "block_storage")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="loadBalancer")
    def load_balancer(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult':
        return pulumi.get(self, "load_balancer")

    @property
    @pulumi.getter
    def metadata(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataResult':
        return pulumi.get(self, "metadata")

    @property
    @pulumi.getter
    def route(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteResult':
        return pulumi.get(self, "route")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult(dict):
    def __init__(__self__, *,
                 bs_version: str,
                 ignore_volume_az: bool,
                 trust_device_path: bool):
        pulumi.set(__self__, "bs_version", bs_version)
        pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> str:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> bool:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> bool:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 auth_url: str,
                 ca_file: str,
                 domain_id: str,
                 domain_name: str,
                 password: str,
                 region: str,
                 tenant_id: str,
                 tenant_name: str,
                 trust_id: str,
                 username: str):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "ca_file", ca_file)
        pulumi.set(__self__, "domain_id", domain_id)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "tenant_name", tenant_name)
        pulumi.set(__self__, "trust_id", trust_id)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> str:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> str:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> str:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> str:
        return pulumi.get(self, "trust_id")

    @property
    @pulumi.getter
    def username(self) -> str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult(dict):
    def __init__(__self__, *,
                 create_monitor: bool,
                 floating_network_id: str,
                 lb_method: str,
                 lb_provider: str,
                 lb_version: str,
                 manage_security_groups: bool,
                 subnet_id: str,
                 use_octavia: bool,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[float] = None,
                 monitor_timeout: Optional[str] = None):
        pulumi.set(__self__, "create_monitor", create_monitor)
        pulumi.set(__self__, "floating_network_id", floating_network_id)
        pulumi.set(__self__, "lb_method", lb_method)
        pulumi.set(__self__, "lb_provider", lb_provider)
        pulumi.set(__self__, "lb_version", lb_version)
        pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "use_octavia", use_octavia)
        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)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> bool:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> str:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> str:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> str:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> str:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> bool:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> bool:
        return pulumi.get(self, "use_octavia")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[float]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[str]:
        return pulumi.get(self, "monitor_timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataResult(dict):
    def __init__(__self__, *,
                 request_timeout: float,
                 search_order: str):
        pulumi.set(__self__, "request_timeout", request_timeout)
        pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> float:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> str:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteResult(dict):
    def __init__(__self__, *,
                 router_id: str):
        pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        return pulumi.get(self, "router_id")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult(dict):
    def __init__(__self__, *,
                 disk: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult',
                 global_: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
                 network: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
                 virtual_centers: List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult'],
                 workspace: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult'):
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "global_", global_)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)

    @property
    @pulumi.getter
    def disk(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult':
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult':
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> List['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult']:
        return pulumi.get(self, "virtual_centers")

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult':
        return pulumi.get(self, "workspace")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult(dict):
    def __init__(__self__, *,
                 scsi_controller_type: str):
        pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> str:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 insecure_flag: bool,
                 password: str,
                 port: str,
                 soap_roundtrip_count: float,
                 user: str):
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "insecure_flag", insecure_flag)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> bool:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> float:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult(dict):
    def __init__(__self__, *,
                 public_network: str):
        pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> str:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 port: str,
                 soap_roundtrip_count: float,
                 user: str):
        """
        :param 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__, "port", port)
        pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> float:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult(dict):
    def __init__(__self__, *,
                 datacenter: str,
                 default_datastore: str,
                 folder: str,
                 resourcepool_path: str,
                 server: str):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "default_datastore", default_datastore)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "resourcepool_path", resourcepool_path)
        pulumi.set(__self__, "server", server)

    @property
    @pulumi.getter
    def datacenter(self) -> str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> str:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter
    def folder(self) -> str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> str:
        return pulumi.get(self, "resourcepool_path")

    @property
    @pulumi.getter
    def server(self) -> str:
        return pulumi.get(self, "server")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult(dict):
    def __init__(__self__, *,
                 node_selector: Mapping[str, Any],
                 reverse_cidrs: List[str],
                 upstream_nameservers: List[str],
                 nodelocal: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[str] = None):
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> List[str]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> List[str]:
        return pulumi.get(self, "upstream_nameservers")

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult']:
        return pulumi.get(self, "nodelocal")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        return pulumi.get(self, "provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult(dict):
    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: str,
                 extra_args: Mapping[str, Any],
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 provider: str):
        pulumi.set(__self__, "dns_policy", dns_policy)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> str:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 provider: str,
                 replicas: float,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult'] = None):
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "provider", provider)
        pulumi.set(__self__, "replicas", replicas)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> float:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[str]:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[float] = None,
                 max_unavailable: Optional[float] = None):
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[float]:
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[float]:
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 plugin: str,
                 calico_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult'] = None,
                 canal_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult'] = None,
                 flannel_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult'] = None,
                 mtu: Optional[float] = None,
                 weave_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult'] = None):
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "plugin", plugin)
        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 weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> str:
        return pulumi.get(self, "plugin")

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult']:
        return pulumi.get(self, "calico_network_provider")

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult']:
        return pulumi.get(self, "canal_network_provider")

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult']:
        return pulumi.get(self, "flannel_network_provider")

    @property
    @pulumi.getter
    def mtu(self) -> Optional[float]:
        return pulumi.get(self, "mtu")

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult']:
        return pulumi.get(self, "weave_network_provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult(dict):
    def __init__(__self__, *,
                 cloud_provider: str):
        pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> str:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult(dict):
    def __init__(__self__, *,
                 password: str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult(dict):
    def __init__(__self__, *,
                 address: str,
                 docker_socket: str,
                 roles: List[str],
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for the cluster template (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "docker_socket", docker_socket)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "user", user)
        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)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> str:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter
    def roles(self) -> List[str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        (Computed) Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult(dict):
    def __init__(__self__, *,
                 url: str,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult',
                 kube_api: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult',
                 kube_controller: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult',
                 kubelet: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult',
                 kubeproxy: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult',
                 scheduler: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult'):
        pulumi.set(__self__, "etcd", etcd)
        pulumi.set(__self__, "kube_api", kube_api)
        pulumi.set(__self__, "kube_controller", kube_controller)
        pulumi.set(__self__, "kubelet", kubelet)
        pulumi.set(__self__, "kubeproxy", kubeproxy)
        pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult':
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult':
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult':
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult':
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult':
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult':
        return pulumi.get(self, "scheduler")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult(dict):
    def __init__(__self__, *,
                 backup_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult',
                 ca_cert: str,
                 cert: str,
                 creation: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 key: str,
                 path: str,
                 retention: str,
                 snapshot: bool,
                 external_urls: Optional[List[str]] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 gid: Optional[float] = None,
                 uid: Optional[float] = None):
        pulumi.set(__self__, "backup_config", backup_config)
        pulumi.set(__self__, "ca_cert", ca_cert)
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "creation", creation)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "retention", retention)
        pulumi.set(__self__, "snapshot", snapshot)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        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 uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult':
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> str:
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> str:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> str:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> bool:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[List[str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[float]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def uid(self) -> Optional[float]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[float] = None,
                 retention: Optional[float] = None,
                 s3_backup_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = 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)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[float]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[float]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[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) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 service_node_port_range: str,
                 admission_configuration: Optional[Mapping[str, Any]] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult'] = None,
                 event_rate_limit: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult'] = None,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult'] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        pulumi.set(__self__, "service_node_port_range", service_node_port_range)
        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_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 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)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> str:
        return pulumi.get(self, "service_node_port_range")

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[bool]:
        return pulumi.get(self, "always_pull_images")

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult']:
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[bool]:
        return pulumi.get(self, "pod_security_policy")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult']:
        return pulumi.get(self, "secrets_encryption_config")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult(dict):
    def __init__(__self__, *,
                 configuration: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult',
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult':
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult(dict):
    def __init__(__self__, *,
                 policy: str,
                 format: Optional[str] = None,
                 max_age: Optional[float] = None,
                 max_backup: Optional[float] = None,
                 max_size: Optional[float] = None,
                 path: Optional[str] = None):
        pulumi.set(__self__, "policy", policy)
        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)

    @property
    @pulumi.getter
    def policy(self) -> str:
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[float]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[float]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[float]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult(dict):
    def __init__(__self__, *,
                 cluster_cidr: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None):
        pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        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)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> str:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult(dict):
    def __init__(__self__, *,
                 cluster_dns_server: str,
                 cluster_domain: str,
                 extra_args: Mapping[str, Any],
                 fail_swap_on: bool,
                 image: str,
                 infra_container_image: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None,
                 generate_serving_certificate: Optional[bool] = None):
        pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        pulumi.set(__self__, "cluster_domain", cluster_domain)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "infra_container_image", infra_container_image)
        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 generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> str:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> str:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> bool:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> str:
        return pulumi.get(self, "infra_container_image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[bool]:
        return pulumi.get(self, "generate_serving_certificate")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        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)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[List[str]] = None,
                 extra_envs: Optional[List[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        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)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[List[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_input: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult',
                 drain: Optional[bool] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        pulumi.set(__self__, "drain_input", drain_input)
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        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(name="drainInput")
    def drain_input(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult':
        return pulumi.get(self, "drain_input")

    @property
    @pulumi.getter
    def drain(self) -> Optional[bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[float] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[float] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[float]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[float]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanResult(dict):
    def __init__(__self__, *,
                 scan_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigResult',
                 schedule_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigResult',
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "scan_config", scan_config)
        pulumi.set(__self__, "schedule_config", schedule_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="scanConfig")
    def scan_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigResult':
        return pulumi.get(self, "scan_config")

    @property
    @pulumi.getter(name="scheduleConfig")
    def schedule_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigResult':
        return pulumi.get(self, "schedule_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigResult(dict):
    def __init__(__self__, *,
                 cis_scan_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigResult'):
        pulumi.set(__self__, "cis_scan_config", cis_scan_config)

    @property
    @pulumi.getter(name="cisScanConfig")
    def cis_scan_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigResult':
        return pulumi.get(self, "cis_scan_config")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigResult(dict):
    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[List[str]] = None,
                 profile: Optional[str] = None):
        if debug_master is not None:
            pulumi.set(__self__, "debug_master", debug_master)
        if debug_worker is not None:
            pulumi.set(__self__, "debug_worker", debug_worker)
        if override_benchmark_version is not None:
            pulumi.set(__self__, "override_benchmark_version", override_benchmark_version)
        if override_skips is not None:
            pulumi.set(__self__, "override_skips", override_skips)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="debugMaster")
    def debug_master(self) -> Optional[bool]:
        return pulumi.get(self, "debug_master")

    @property
    @pulumi.getter(name="debugWorker")
    def debug_worker(self) -> Optional[bool]:
        return pulumi.get(self, "debug_worker")

    @property
    @pulumi.getter(name="overrideBenchmarkVersion")
    def override_benchmark_version(self) -> Optional[str]:
        return pulumi.get(self, "override_benchmark_version")

    @property
    @pulumi.getter(name="overrideSkips")
    def override_skips(self) -> Optional[List[str]]:
        return pulumi.get(self, "override_skips")

    @property
    @pulumi.getter
    def profile(self) -> Optional[str]:
        return pulumi.get(self, "profile")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigResult(dict):
    def __init__(__self__, *,
                 cron_schedule: str,
                 retention: float):
        pulumi.set(__self__, "cron_schedule", cron_schedule)
        pulumi.set(__self__, "retention", retention)

    @property
    @pulumi.getter(name="cronSchedule")
    def cron_schedule(self) -> str:
        return pulumi.get(self, "cron_schedule")

    @property
    @pulumi.getter
    def retention(self) -> float:
        return pulumi.get(self, "retention")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionQuestionResult(dict):
    def __init__(__self__, *,
                 default: str,
                 variable: str,
                 required: Optional[bool] = None,
                 type: Optional[str] = None):
        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) -> str:
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> str:
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[bool]:
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        return pulumi.get(self, "type")


@pulumi.output_type
class GetEtcdBackupBackupConfigResult(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[float] = None,
                 retention: Optional[float] = None,
                 s3_backup_config: Optional['outputs.GetEtcdBackupBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = 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)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[float]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[float]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.GetEtcdBackupBackupConfigS3BackupConfigResult']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetEtcdBackupBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[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) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetMultiClusterAppAnswerResult(dict):
    def __init__(__self__, *,
                 cluster_id: str,
                 project_id: str,
                 values: Mapping[str, Any]):
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def values(self) -> Mapping[str, Any]:
        return pulumi.get(self, "values")


@pulumi.output_type
class GetMultiClusterAppMemberResult(dict):
    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        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[str]:
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[str]:
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        return pulumi.get(self, "user_principal_id")


@pulumi.output_type
class GetMultiClusterAppTargetResult(dict):
    def __init__(__self__, *,
                 app_id: str,
                 health_state: str,
                 project_id: str,
                 state: str):
        pulumi.set(__self__, "app_id", app_id)
        pulumi.set(__self__, "health_state", health_state)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> str:
        return pulumi.get(self, "app_id")

    @property
    @pulumi.getter(name="healthState")
    def health_state(self) -> str:
        return pulumi.get(self, "health_state")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        return pulumi.get(self, "state")


@pulumi.output_type
class GetMultiClusterAppUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetMultiClusterAppUpgradeStrategyRollingUpdateResult'] = None):
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetMultiClusterAppUpgradeStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")


@pulumi.output_type
class GetMultiClusterAppUpgradeStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 batch_size: Optional[float] = None,
                 interval: Optional[float] = None):
        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[float]:
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def interval(self) -> Optional[float]:
        return pulumi.get(self, "interval")


@pulumi.output_type
class GetNamespaceContainerResourceLimitResult(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[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[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")


@pulumi.output_type
class GetNamespaceResourceQuotaResult(dict):
    def __init__(__self__, *,
                 limit: 'outputs.GetNamespaceResourceQuotaLimitResult'):
        pulumi.set(__self__, "limit", limit)

    @property
    @pulumi.getter
    def limit(self) -> 'outputs.GetNamespaceResourceQuotaLimitResult':
        return pulumi.get(self, "limit")


@pulumi.output_type
class GetNamespaceResourceQuotaLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[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[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetNodePoolNodeTaintResult(dict):
    def __init__(__self__, *,
                 key: str,
                 time_added: str,
                 value: str,
                 effect: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "time_added", time_added)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> str:
        return pulumi.get(self, "time_added")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetNotifierPagerdutyConfigResult(dict):
    def __init__(__self__, *,
                 service_key: str,
                 proxy_url: Optional[str] = None):
        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) -> str:
        return pulumi.get(self, "service_key")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierSlackConfigResult(dict):
    def __init__(__self__, *,
                 default_recipient: str,
                 url: str,
                 proxy_url: Optional[str] = None):
        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) -> str:
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierSmtpConfigResult(dict):
    def __init__(__self__, *,
                 default_recipient: str,
                 host: str,
                 port: float,
                 sender: str,
                 password: Optional[str] = None,
                 tls: Optional[bool] = None,
                 username: Optional[str] = None):
        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) -> str:
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def host(self) -> str:
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> float:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def sender(self) -> str:
        return pulumi.get(self, "sender")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def tls(self) -> Optional[bool]:
        return pulumi.get(self, "tls")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetNotifierWebhookConfigResult(dict):
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        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:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierWechatConfigResult(dict):
    def __init__(__self__, *,
                 agent: str,
                 corp: str,
                 default_recipient: str,
                 secret: str,
                 proxy_url: Optional[str] = None,
                 recipient_type: Optional[str] = None):
        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) -> str:
        return pulumi.get(self, "agent")

    @property
    @pulumi.getter
    def corp(self) -> str:
        return pulumi.get(self, "corp")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def secret(self) -> str:
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        return pulumi.get(self, "proxy_url")

    @property
    @pulumi.getter(name="recipientType")
    def recipient_type(self) -> Optional[str]:
        return pulumi.get(self, "recipient_type")


@pulumi.output_type
class GetPodSecurityPolicyTemplateAllowedCsiDriverResult(dict):
    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")


@pulumi.output_type
class GetPodSecurityPolicyTemplateAllowedFlexVolumeResult(dict):
    def __init__(__self__, *,
                 driver: str):
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> str:
        return pulumi.get(self, "driver")


@pulumi.output_type
class GetPodSecurityPolicyTemplateAllowedHostPathResult(dict):
    def __init__(__self__, *,
                 path_prefix: str,
                 read_only: Optional[bool] = None):
        pulumi.set(__self__, "path_prefix", path_prefix)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="pathPrefix")
    def path_prefix(self) -> str:
        return pulumi.get(self, "path_prefix")

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[bool]:
        return pulumi.get(self, "read_only")


@pulumi.output_type
class GetPodSecurityPolicyTemplateFsGroupResult(dict):
    def __init__(__self__, *,
                 ranges: List['outputs.GetPodSecurityPolicyTemplateFsGroupRangeResult'],
                 rule: Optional[str] = None):
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> List['outputs.GetPodSecurityPolicyTemplateFsGroupRangeResult']:
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        return pulumi.get(self, "rule")


@pulumi.output_type
class GetPodSecurityPolicyTemplateFsGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateHostPortResult(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsGroupResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[List['outputs.GetPodSecurityPolicyTemplateRunAsGroupRangeResult']] = None):
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['outputs.GetPodSecurityPolicyTemplateRunAsGroupRangeResult']]:
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsUserResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[List['outputs.GetPodSecurityPolicyTemplateRunAsUserRangeResult']] = None):
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[List['outputs.GetPodSecurityPolicyTemplateRunAsUserRangeResult']]:
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsUserRangeResult(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRuntimeClassResult(dict):
    def __init__(__self__, *,
                 allowed_runtime_class_names: List[str],
                 default_runtime_class_name: Optional[str] = None):
        pulumi.set(__self__, "allowed_runtime_class_names", allowed_runtime_class_names)
        if default_runtime_class_name is not None:
            pulumi.set(__self__, "default_runtime_class_name", default_runtime_class_name)

    @property
    @pulumi.getter(name="allowedRuntimeClassNames")
    def allowed_runtime_class_names(self) -> List[str]:
        return pulumi.get(self, "allowed_runtime_class_names")

    @property
    @pulumi.getter(name="defaultRuntimeClassName")
    def default_runtime_class_name(self) -> Optional[str]:
        return pulumi.get(self, "default_runtime_class_name")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSeLinuxResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 se_linux_option: Optional['outputs.GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult'] = None):
        pulumi.set(__self__, "rule", rule)
        if se_linux_option is not None:
            pulumi.set(__self__, "se_linux_option", se_linux_option)

    @property
    @pulumi.getter
    def rule(self) -> str:
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter(name="seLinuxOption")
    def se_linux_option(self) -> Optional['outputs.GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult']:
        return pulumi.get(self, "se_linux_option")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult(dict):
    def __init__(__self__, *,
                 level: Optional[str] = None,
                 role: Optional[str] = None,
                 type: Optional[str] = None,
                 user: Optional[str] = None):
        if level is not None:
            pulumi.set(__self__, "level", level)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def level(self) -> Optional[str]:
        return pulumi.get(self, "level")

    @property
    @pulumi.getter
    def role(self) -> Optional[str]:
        return pulumi.get(self, "role")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSupplementalGroupResult(dict):
    def __init__(__self__, *,
                 ranges: List['outputs.GetPodSecurityPolicyTemplateSupplementalGroupRangeResult'],
                 rule: Optional[str] = None):
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> List['outputs.GetPodSecurityPolicyTemplateSupplementalGroupRangeResult']:
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        return pulumi.get(self, "rule")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSupplementalGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: float,
                 min: float):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> float:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> float:
        return pulumi.get(self, "min")


@pulumi.output_type
class GetProjectAlertGroupRecipientResult(dict):
    def __init__(__self__, *,
                 notifier_id: str,
                 notifier_type: str,
                 recipient: str,
                 default_recipient: Optional[bool] = None):
        pulumi.set(__self__, "notifier_id", notifier_id)
        pulumi.set(__self__, "notifier_type", notifier_type)
        pulumi.set(__self__, "recipient", recipient)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> str:
        return pulumi.get(self, "notifier_id")

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> str:
        return pulumi.get(self, "notifier_type")

    @property
    @pulumi.getter
    def recipient(self) -> str:
        return pulumi.get(self, "recipient")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[bool]:
        return pulumi.get(self, "default_recipient")


@pulumi.output_type
class GetProjectAlertRuleMetricRuleResult(dict):
    def __init__(__self__, *,
                 duration: str,
                 expression: str,
                 threshold_value: float,
                 comparison: Optional[str] = None,
                 description: Optional[str] = None):
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> str:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def expression(self) -> str:
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> float:
        return pulumi.get(self, "threshold_value")

    @property
    @pulumi.getter
    def comparison(self) -> Optional[str]:
        return pulumi.get(self, "comparison")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")


@pulumi.output_type
class GetProjectAlertRulePodRuleResult(dict):
    def __init__(__self__, *,
                 pod_id: str,
                 condition: Optional[str] = None,
                 restart_interval_seconds: Optional[float] = None,
                 restart_times: Optional[float] = None):
        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) -> str:
        return pulumi.get(self, "pod_id")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="restartIntervalSeconds")
    def restart_interval_seconds(self) -> Optional[float]:
        return pulumi.get(self, "restart_interval_seconds")

    @property
    @pulumi.getter(name="restartTimes")
    def restart_times(self) -> Optional[float]:
        return pulumi.get(self, "restart_times")


@pulumi.output_type
class GetProjectAlertRuleWorkloadRuleResult(dict):
    def __init__(__self__, *,
                 available_percentage: Optional[float] = None,
                 selector: Optional[Mapping[str, Any]] = None,
                 workload_id: Optional[str] = None):
        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[float]:
        return pulumi.get(self, "available_percentage")

    @property
    @pulumi.getter
    def selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "selector")

    @property
    @pulumi.getter(name="workloadId")
    def workload_id(self) -> Optional[str]:
        return pulumi.get(self, "workload_id")


@pulumi.output_type
class GetProjectContainerResourceLimitResult(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[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[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")


@pulumi.output_type
class GetProjectLoggingCustomTargetConfigResult(dict):
    def __init__(__self__, *,
                 content: str,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None):
        pulumi.set(__self__, "content", content)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)

    @property
    @pulumi.getter
    def content(self) -> str:
        return pulumi.get(self, "content")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")


@pulumi.output_type
class GetProjectLoggingElasticsearchConfigResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 ssl_verify: bool,
                 auth_password: Optional[str] = None,
                 auth_username: Optional[str] = None,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 client_key_pass: Optional[str] = None,
                 date_format: Optional[str] = None,
                 index_prefix: Optional[str] = None,
                 ssl_version: Optional[str] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "ssl_verify", ssl_verify)
        if auth_password is not None:
            pulumi.set(__self__, "auth_password", auth_password)
        if auth_username is not None:
            pulumi.set(__self__, "auth_username", auth_username)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if date_format is not None:
            pulumi.set(__self__, "date_format", date_format)
        if index_prefix is not None:
            pulumi.set(__self__, "index_prefix", index_prefix)
        if ssl_version is not None:
            pulumi.set(__self__, "ssl_version", ssl_version)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> bool:
        return pulumi.get(self, "ssl_verify")

    @property
    @pulumi.getter(name="authPassword")
    def auth_password(self) -> Optional[str]:
        return pulumi.get(self, "auth_password")

    @property
    @pulumi.getter(name="authUsername")
    def auth_username(self) -> Optional[str]:
        return pulumi.get(self, "auth_username")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[str]:
        return pulumi.get(self, "client_key_pass")

    @property
    @pulumi.getter(name="dateFormat")
    def date_format(self) -> Optional[str]:
        return pulumi.get(self, "date_format")

    @property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> Optional[str]:
        return pulumi.get(self, "index_prefix")

    @property
    @pulumi.getter(name="sslVersion")
    def ssl_version(self) -> Optional[str]:
        return pulumi.get(self, "ssl_version")


@pulumi.output_type
class GetProjectLoggingFluentdConfigResult(dict):
    def __init__(__self__, *,
                 fluent_servers: List['outputs.GetProjectLoggingFluentdConfigFluentServerResult'],
                 certificate: Optional[str] = None,
                 compress: Optional[bool] = None,
                 enable_tls: Optional[bool] = None):
        pulumi.set(__self__, "fluent_servers", fluent_servers)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)

    @property
    @pulumi.getter(name="fluentServers")
    def fluent_servers(self) -> List['outputs.GetProjectLoggingFluentdConfigFluentServerResult']:
        return pulumi.get(self, "fluent_servers")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def compress(self) -> Optional[bool]:
        return pulumi.get(self, "compress")

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[bool]:
        return pulumi.get(self, "enable_tls")


@pulumi.output_type
class GetProjectLoggingFluentdConfigFluentServerResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 hostname: Optional[str] = None,
                 password: Optional[str] = None,
                 shared_key: Optional[str] = None,
                 standby: Optional[bool] = None,
                 username: Optional[str] = None,
                 weight: Optional[float] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if shared_key is not None:
            pulumi.set(__self__, "shared_key", shared_key)
        if standby is not None:
            pulumi.set(__self__, "standby", standby)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter
    def hostname(self) -> Optional[str]:
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="sharedKey")
    def shared_key(self) -> Optional[str]:
        return pulumi.get(self, "shared_key")

    @property
    @pulumi.getter
    def standby(self) -> Optional[bool]:
        return pulumi.get(self, "standby")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")

    @property
    @pulumi.getter
    def weight(self) -> Optional[float]:
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetProjectLoggingKafkaConfigResult(dict):
    def __init__(__self__, *,
                 topic: str,
                 broker_endpoints: Optional[List[str]] = None,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 zookeeper_endpoint: Optional[str] = None):
        pulumi.set(__self__, "topic", topic)
        if broker_endpoints is not None:
            pulumi.set(__self__, "broker_endpoints", broker_endpoints)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if zookeeper_endpoint is not None:
            pulumi.set(__self__, "zookeeper_endpoint", zookeeper_endpoint)

    @property
    @pulumi.getter
    def topic(self) -> str:
        return pulumi.get(self, "topic")

    @property
    @pulumi.getter(name="brokerEndpoints")
    def broker_endpoints(self) -> Optional[List[str]]:
        return pulumi.get(self, "broker_endpoints")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="zookeeperEndpoint")
    def zookeeper_endpoint(self) -> Optional[str]:
        return pulumi.get(self, "zookeeper_endpoint")


@pulumi.output_type
class GetProjectLoggingSplunkConfigResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 ssl_verify: bool,
                 token: str,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 client_key_pass: Optional[str] = None,
                 index: Optional[str] = None,
                 source: Optional[str] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "ssl_verify", ssl_verify)
        pulumi.set(__self__, "token", token)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if client_key_pass is not None:
            pulumi.set(__self__, "client_key_pass", client_key_pass)
        if index is not None:
            pulumi.set(__self__, "index", index)
        if source is not None:
            pulumi.set(__self__, "source", source)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> bool:
        return pulumi.get(self, "ssl_verify")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="clientKeyPass")
    def client_key_pass(self) -> Optional[str]:
        return pulumi.get(self, "client_key_pass")

    @property
    @pulumi.getter
    def index(self) -> Optional[str]:
        return pulumi.get(self, "index")

    @property
    @pulumi.getter
    def source(self) -> Optional[str]:
        return pulumi.get(self, "source")


@pulumi.output_type
class GetProjectLoggingSyslogConfigResult(dict):
    def __init__(__self__, *,
                 endpoint: str,
                 ssl_verify: bool,
                 certificate: Optional[str] = None,
                 client_cert: Optional[str] = None,
                 client_key: Optional[str] = None,
                 enable_tls: Optional[bool] = None,
                 program: Optional[str] = None,
                 protocol: Optional[str] = None,
                 severity: Optional[str] = None,
                 token: Optional[str] = None):
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "ssl_verify", ssl_verify)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_cert is not None:
            pulumi.set(__self__, "client_cert", client_cert)
        if client_key is not None:
            pulumi.set(__self__, "client_key", client_key)
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)
        if program is not None:
            pulumi.set(__self__, "program", program)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="sslVerify")
    def ssl_verify(self) -> bool:
        return pulumi.get(self, "ssl_verify")

    @property
    @pulumi.getter
    def certificate(self) -> Optional[str]:
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="clientCert")
    def client_cert(self) -> Optional[str]:
        return pulumi.get(self, "client_cert")

    @property
    @pulumi.getter(name="clientKey")
    def client_key(self) -> Optional[str]:
        return pulumi.get(self, "client_key")

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[bool]:
        return pulumi.get(self, "enable_tls")

    @property
    @pulumi.getter
    def program(self) -> Optional[str]:
        return pulumi.get(self, "program")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def severity(self) -> Optional[str]:
        return pulumi.get(self, "severity")

    @property
    @pulumi.getter
    def token(self) -> Optional[str]:
        return pulumi.get(self, "token")


@pulumi.output_type
class GetProjectResourceQuotaResult(dict):
    def __init__(__self__, *,
                 namespace_default_limit: 'outputs.GetProjectResourceQuotaNamespaceDefaultLimitResult',
                 project_limit: 'outputs.GetProjectResourceQuotaProjectLimitResult'):
        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) -> 'outputs.GetProjectResourceQuotaNamespaceDefaultLimitResult':
        return pulumi.get(self, "namespace_default_limit")

    @property
    @pulumi.getter(name="projectLimit")
    def project_limit(self) -> 'outputs.GetProjectResourceQuotaProjectLimitResult':
        return pulumi.get(self, "project_limit")


@pulumi.output_type
class GetProjectResourceQuotaNamespaceDefaultLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[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[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetProjectResourceQuotaProjectLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[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[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetRegistryRegistryResult(dict):
    def __init__(__self__, *,
                 address: str,
                 password: Optional[str] = None,
                 username: Optional[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) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetRoleTempalteRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[List[str]] = None,
                 non_resource_urls: Optional[List[str]] = None,
                 resource_names: Optional[List[str]] = None,
                 resources: Optional[List[str]] = None,
                 verbs: Optional[List[str]] = None):
        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[List[str]]:
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[List[str]]:
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[List[str]]:
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[List[str]]:
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[List[str]]:
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetRoleTemplateRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[List[str]] = None,
                 non_resource_urls: Optional[List[str]] = None,
                 resource_names: Optional[List[str]] = None,
                 resources: Optional[List[str]] = None,
                 verbs: Optional[List[str]] = None):
        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[List[str]]:
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[List[str]]:
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[List[str]]:
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[List[str]]:
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[List[str]]:
        return pulumi.get(self, "verbs")


