# 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, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs

__all__ = [
    'CloudCredentialAmazonec2CredentialConfig',
    'CloudCredentialAzureCredentialConfig',
    'CloudCredentialDigitaloceanCredentialConfig',
    'CloudCredentialGoogleCredentialConfig',
    'CloudCredentialLinodeCredentialConfig',
    'CloudCredentialOpenstackCredentialConfig',
    'CloudCredentialS3CredentialConfig',
    'CloudCredentialVsphereCredentialConfig',
    'ClusterAgentEnvVar',
    'ClusterAksConfig',
    'ClusterAksConfigV2',
    'ClusterAksConfigV2NodePool',
    'ClusterAlertGroupRecipient',
    'ClusterAlertRuleEventRule',
    'ClusterAlertRuleMetricRule',
    'ClusterAlertRuleNodeRule',
    'ClusterAlertRuleSystemServiceRule',
    'ClusterAlterGroupRecipient',
    'ClusterAlterRuleEventRule',
    'ClusterAlterRuleMetricRule',
    'ClusterAlterRuleNodeRule',
    'ClusterAlterRuleSystemServiceRule',
    'ClusterClusterAuthEndpoint',
    'ClusterClusterMonitoringInput',
    'ClusterClusterRegistrationToken',
    'ClusterClusterTemplateAnswers',
    'ClusterClusterTemplateQuestion',
    'ClusterEksConfig',
    'ClusterEksConfigV2',
    'ClusterEksConfigV2NodeGroup',
    'ClusterEksConfigV2NodeGroupLaunchTemplate',
    'ClusterGkeConfig',
    'ClusterGkeConfigV2',
    'ClusterGkeConfigV2ClusterAddons',
    'ClusterGkeConfigV2IpAllocationPolicy',
    'ClusterGkeConfigV2MasterAuthorizedNetworksConfig',
    'ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock',
    'ClusterGkeConfigV2NodePool',
    'ClusterGkeConfigV2NodePoolAutoscaling',
    'ClusterGkeConfigV2NodePoolConfig',
    'ClusterGkeConfigV2NodePoolConfigTaint',
    'ClusterGkeConfigV2NodePoolManagement',
    'ClusterGkeConfigV2PrivateClusterConfig',
    'ClusterK3sConfig',
    'ClusterK3sConfigUpgradeStrategy',
    'ClusterLoggingCustomTargetConfig',
    'ClusterLoggingElasticsearchConfig',
    'ClusterLoggingFluentdConfig',
    'ClusterLoggingFluentdConfigFluentServer',
    'ClusterLoggingKafkaConfig',
    'ClusterLoggingSplunkConfig',
    'ClusterLoggingSyslogConfig',
    'ClusterOkeConfig',
    'ClusterRke2Config',
    'ClusterRke2ConfigUpgradeStrategy',
    'ClusterRkeConfig',
    'ClusterRkeConfigAuthentication',
    'ClusterRkeConfigAuthorization',
    'ClusterRkeConfigBastionHost',
    'ClusterRkeConfigCloudProvider',
    'ClusterRkeConfigCloudProviderAwsCloudProvider',
    'ClusterRkeConfigCloudProviderAwsCloudProviderGlobal',
    'ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride',
    'ClusterRkeConfigCloudProviderAzureCloudProvider',
    'ClusterRkeConfigCloudProviderOpenstackCloudProvider',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata',
    'ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute',
    'ClusterRkeConfigCloudProviderVsphereCloudProvider',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderDisk',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter',
    'ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace',
    'ClusterRkeConfigDns',
    'ClusterRkeConfigDnsLinearAutoscalerParams',
    'ClusterRkeConfigDnsNodelocal',
    'ClusterRkeConfigDnsToleration',
    'ClusterRkeConfigDnsUpdateStrategy',
    'ClusterRkeConfigDnsUpdateStrategyRollingUpdate',
    'ClusterRkeConfigIngress',
    'ClusterRkeConfigIngressToleration',
    'ClusterRkeConfigIngressUpdateStrategy',
    'ClusterRkeConfigIngressUpdateStrategyRollingUpdate',
    'ClusterRkeConfigMonitoring',
    'ClusterRkeConfigMonitoringToleration',
    'ClusterRkeConfigMonitoringUpdateStrategy',
    'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate',
    'ClusterRkeConfigNetwork',
    'ClusterRkeConfigNetworkCalicoNetworkProvider',
    'ClusterRkeConfigNetworkCanalNetworkProvider',
    'ClusterRkeConfigNetworkFlannelNetworkProvider',
    'ClusterRkeConfigNetworkToleration',
    'ClusterRkeConfigNetworkWeaveNetworkProvider',
    'ClusterRkeConfigNode',
    'ClusterRkeConfigPrivateRegistry',
    'ClusterRkeConfigPrivateRegistryEcrCredentialPlugin',
    'ClusterRkeConfigServices',
    'ClusterRkeConfigServicesEtcd',
    'ClusterRkeConfigServicesEtcdBackupConfig',
    'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig',
    'ClusterRkeConfigServicesKubeApi',
    'ClusterRkeConfigServicesKubeApiAuditLog',
    'ClusterRkeConfigServicesKubeApiAuditLogConfiguration',
    'ClusterRkeConfigServicesKubeApiEventRateLimit',
    'ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig',
    'ClusterRkeConfigServicesKubeController',
    'ClusterRkeConfigServicesKubelet',
    'ClusterRkeConfigServicesKubeproxy',
    'ClusterRkeConfigServicesScheduler',
    'ClusterRkeConfigUpgradeStrategy',
    'ClusterRkeConfigUpgradeStrategyDrainInput',
    'ClusterScheduledClusterScan',
    'ClusterScheduledClusterScanScanConfig',
    'ClusterScheduledClusterScanScanConfigCisScanConfig',
    'ClusterScheduledClusterScanScheduleConfig',
    'ClusterSyncNode',
    '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',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringToleration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig',
    'ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig',
    'ClusterTemplateTemplateRevisionQuestion',
    'ClusterV2AgentEnvVar',
    'ClusterV2ClusterRegistrationToken',
    'ClusterV2LocalAuthEndpoint',
    'ClusterV2RkeConfig',
    'ClusterV2RkeConfigEtcd',
    'ClusterV2RkeConfigEtcdS3Config',
    'ClusterV2RkeConfigLocalAuthEndpoint',
    'ClusterV2RkeConfigMachinePool',
    'ClusterV2RkeConfigMachinePoolMachineConfig',
    'ClusterV2RkeConfigMachinePoolRollingUpdate',
    'ClusterV2RkeConfigMachinePoolTaint',
    'ClusterV2RkeConfigMachineSelectorConfig',
    'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector',
    'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression',
    'ClusterV2RkeConfigRegistries',
    'ClusterV2RkeConfigRegistriesConfig',
    'ClusterV2RkeConfigRegistriesMirror',
    'ClusterV2RkeConfigUpgradeStrategy',
    'ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions',
    'ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions',
    'EtcdBackupBackupConfig',
    'EtcdBackupBackupConfigS3BackupConfig',
    'GlobalDnsProviderAlidnsConfig',
    'GlobalDnsProviderCloudflareConfig',
    'GlobalDnsProviderRoute53Config',
    'GlobalRoleRule',
    'MachineConfigV2Amazonec2Config',
    'MachineConfigV2AzureConfig',
    'MachineConfigV2DigitaloceanConfig',
    'MachineConfigV2LinodeConfig',
    'MachineConfigV2OpenstackConfig',
    'MachineConfigV2VsphereConfig',
    'MultiClusterAppAnswer',
    'MultiClusterAppMember',
    'MultiClusterAppTarget',
    'MultiClusterAppUpgradeStrategy',
    'MultiClusterAppUpgradeStrategyRollingUpdate',
    'NamespaceContainerResourceLimit',
    'NamespaceResourceQuota',
    'NamespaceResourceQuotaLimit',
    'NodePoolNodeTaint',
    'NodeTemplateAmazonec2Config',
    'NodeTemplateAzureConfig',
    'NodeTemplateDigitaloceanConfig',
    'NodeTemplateHetznerConfig',
    'NodeTemplateLinodeConfig',
    'NodeTemplateNodeTaint',
    'NodeTemplateOpennebulaConfig',
    'NodeTemplateOpenstackConfig',
    'NodeTemplateVsphereConfig',
    'NotifierDingtalkConfig',
    'NotifierMsteamsConfig',
    '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',
    'RoleTemplateRule',
    'GetClusterAksConfigResult',
    'GetClusterAksConfigV2Result',
    'GetClusterAksConfigV2NodePoolResult',
    'GetClusterAlertGroupRecipientResult',
    'GetClusterAlterRuleEventRuleResult',
    'GetClusterAlterRuleMetricRuleResult',
    'GetClusterAlterRuleNodeRuleResult',
    'GetClusterAlterRuleSystemServiceRuleResult',
    'GetClusterClusterAuthEndpointResult',
    'GetClusterClusterMonitoringInputResult',
    'GetClusterClusterRegistrationTokenResult',
    'GetClusterClusterTemplateAnswersResult',
    'GetClusterClusterTemplateQuestionResult',
    'GetClusterEksConfigResult',
    'GetClusterEksConfigV2Result',
    'GetClusterEksConfigV2NodeGroupResult',
    'GetClusterEksConfigV2NodeGroupLaunchTemplateResult',
    'GetClusterGkeConfigResult',
    'GetClusterGkeConfigV2Result',
    'GetClusterGkeConfigV2ClusterAddonsResult',
    'GetClusterGkeConfigV2IpAllocationPolicyResult',
    'GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult',
    'GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult',
    'GetClusterGkeConfigV2NodePoolResult',
    'GetClusterGkeConfigV2NodePoolAutoscalingResult',
    'GetClusterGkeConfigV2NodePoolConfigResult',
    'GetClusterGkeConfigV2NodePoolConfigTaintResult',
    'GetClusterGkeConfigV2NodePoolManagementResult',
    'GetClusterGkeConfigV2PrivateClusterConfigResult',
    'GetClusterK3sConfigResult',
    'GetClusterK3sConfigUpgradeStrategyResult',
    'GetClusterLoggingCustomTargetConfigResult',
    'GetClusterLoggingElasticsearchConfigResult',
    'GetClusterLoggingFluentdConfigResult',
    'GetClusterLoggingFluentdConfigFluentServerResult',
    'GetClusterLoggingKafkaConfigResult',
    'GetClusterLoggingSplunkConfigResult',
    'GetClusterLoggingSyslogConfigResult',
    'GetClusterOkeConfigResult',
    'GetClusterRke2ConfigResult',
    'GetClusterRke2ConfigUpgradeStrategyResult',
    'GetClusterRkeConfigResult',
    'GetClusterRkeConfigAuthenticationResult',
    'GetClusterRkeConfigAuthorizationResult',
    'GetClusterRkeConfigBastionHostResult',
    'GetClusterRkeConfigCloudProviderResult',
    'GetClusterRkeConfigCloudProviderAwsCloudProviderResult',
    'GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult',
    'GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult',
    'GetClusterRkeConfigCloudProviderAzureCloudProviderResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorageResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult',
    'GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult',
    'GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult',
    'GetClusterRkeConfigDnsResult',
    'GetClusterRkeConfigDnsLinearAutoscalerParamsResult',
    'GetClusterRkeConfigDnsNodelocalResult',
    'GetClusterRkeConfigDnsTolerationResult',
    'GetClusterRkeConfigDnsUpdateStrategyResult',
    'GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult',
    'GetClusterRkeConfigIngressResult',
    'GetClusterRkeConfigIngressTolerationResult',
    'GetClusterRkeConfigIngressUpdateStrategyResult',
    'GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult',
    'GetClusterRkeConfigMonitoringResult',
    'GetClusterRkeConfigMonitoringTolerationResult',
    'GetClusterRkeConfigMonitoringUpdateStrategyResult',
    'GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult',
    'GetClusterRkeConfigNetworkResult',
    'GetClusterRkeConfigNetworkCalicoNetworkProviderResult',
    'GetClusterRkeConfigNetworkCanalNetworkProviderResult',
    'GetClusterRkeConfigNetworkFlannelNetworkProviderResult',
    'GetClusterRkeConfigNetworkTolerationResult',
    'GetClusterRkeConfigNetworkWeaveNetworkProviderResult',
    'GetClusterRkeConfigNodeResult',
    'GetClusterRkeConfigPrivateRegistryResult',
    'GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult',
    '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',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfigResult',
    'GetClusterTemplateTemplateRevisionQuestionResult',
    'GetClusterV2AgentEnvVarResult',
    'GetClusterV2ClusterRegistrationTokenResult',
    'GetClusterV2RkeConfigResult',
    'GetClusterV2RkeConfigEtcdResult',
    'GetClusterV2RkeConfigEtcdS3ConfigResult',
    'GetClusterV2RkeConfigLocalAuthEndpointResult',
    'GetClusterV2RkeConfigMachinePoolResult',
    'GetClusterV2RkeConfigMachinePoolMachineConfigResult',
    'GetClusterV2RkeConfigMachinePoolRollingUpdateResult',
    'GetClusterV2RkeConfigMachinePoolTaintResult',
    'GetClusterV2RkeConfigMachineSelectorConfigResult',
    'GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult',
    'GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult',
    'GetClusterV2RkeConfigRegistriesResult',
    'GetClusterV2RkeConfigRegistriesConfigResult',
    'GetClusterV2RkeConfigRegistriesMirrorResult',
    'GetClusterV2RkeConfigUpgradeStrategyResult',
    'GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult',
    'GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult',
    'GetEtcdBackupBackupConfigResult',
    'GetEtcdBackupBackupConfigS3BackupConfigResult',
    'GetGlobalDnsProviderAlidnsConfigResult',
    'GetGlobalDnsProviderCloudflareConfigResult',
    'GetGlobalDnsProviderRoute53ConfigResult',
    'GetGlobalRoleRuleResult',
    'GetMultiClusterAppAnswerResult',
    'GetMultiClusterAppMemberResult',
    'GetMultiClusterAppTargetResult',
    'GetMultiClusterAppUpgradeStrategyResult',
    'GetMultiClusterAppUpgradeStrategyRollingUpdateResult',
    'GetNamespaceContainerResourceLimitResult',
    'GetNamespaceResourceQuotaResult',
    'GetNamespaceResourceQuotaLimitResult',
    'GetNodePoolNodeTaintResult',
    'GetNodeTemplateNodeTaintResult',
    'GetNotifierDingtalkConfigResult',
    'GetNotifierMsteamsConfigResult',
    '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):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "defaultRegion":
            suggest = "default_region"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CloudCredentialAmazonec2CredentialConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CloudCredentialAmazonec2CredentialConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CloudCredentialAmazonec2CredentialConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 default_region: Optional[str] = None):
        """
        :param str access_key: AWS access key (string)
        :param str secret_key: AWS secret key (string)
        :param str default_region: AWS default region (string)
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if default_region is not None:
            pulumi.set(__self__, "default_region", default_region)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> 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")

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


@pulumi.output_type
class CloudCredentialAzureCredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CloudCredentialAzureCredentialConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CloudCredentialAzureCredentialConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CloudCredentialAzureCredentialConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str,
                 subscription_id: str,
                 environment: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :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)
        :param str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud) (string)
        :param str tenant_id: Azure Tenant ID (string)
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> 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")

    @property
    @pulumi.getter
    def environment(self) -> Optional[str]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud) (string)
        """
        return pulumi.get(self, "environment")

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


@pulumi.output_type
class CloudCredentialDigitaloceanCredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessToken":
            suggest = "access_token"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CloudCredentialDigitaloceanCredentialConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CloudCredentialDigitaloceanCredentialConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CloudCredentialDigitaloceanCredentialConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class CloudCredentialGoogleCredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authEncodedJson":
            suggest = "auth_encoded_json"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CloudCredentialGoogleCredentialConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CloudCredentialGoogleCredentialConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CloudCredentialGoogleCredentialConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auth_encoded_json: str):
        """
        :param str auth_encoded_json: Google auth encoded json (string)
        """
        pulumi.set(__self__, "auth_encoded_json", auth_encoded_json)

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


@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")


@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")


@pulumi.output_type
class CloudCredentialS3CredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "defaultBucket":
            suggest = "default_bucket"
        elif key == "defaultEndpoint":
            suggest = "default_endpoint"
        elif key == "defaultEndpointCa":
            suggest = "default_endpoint_ca"
        elif key == "defaultFolder":
            suggest = "default_folder"
        elif key == "defaultRegion":
            suggest = "default_region"
        elif key == "defaultSkipSslVerify":
            suggest = "default_skip_ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CloudCredentialS3CredentialConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CloudCredentialS3CredentialConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CloudCredentialS3CredentialConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 default_bucket: Optional[str] = None,
                 default_endpoint: Optional[str] = None,
                 default_endpoint_ca: Optional[str] = None,
                 default_folder: Optional[str] = None,
                 default_region: Optional[str] = None,
                 default_skip_ssl_verify: Optional[bool] = None):
        """
        :param str access_key: AWS access key (string)
        :param str secret_key: AWS secret key (string)
        :param str default_bucket: AWS default bucket (string)
        :param str default_endpoint: AWS default endpoint (string)
        :param str default_endpoint_ca: AWS default endpoint CA (string)
        :param str default_folder: AWS default folder (string)
        :param str default_region: AWS default region (string)
        :param bool default_skip_ssl_verify: AWS default skip ssl verify. Default: `false` (bool)
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if default_bucket is not None:
            pulumi.set(__self__, "default_bucket", default_bucket)
        if default_endpoint is not None:
            pulumi.set(__self__, "default_endpoint", default_endpoint)
        if default_endpoint_ca is not None:
            pulumi.set(__self__, "default_endpoint_ca", default_endpoint_ca)
        if default_folder is not None:
            pulumi.set(__self__, "default_folder", default_folder)
        if default_region is not None:
            pulumi.set(__self__, "default_region", default_region)
        if default_skip_ssl_verify is not None:
            pulumi.set(__self__, "default_skip_ssl_verify", default_skip_ssl_verify)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> 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")

    @property
    @pulumi.getter(name="defaultBucket")
    def default_bucket(self) -> Optional[str]:
        """
        AWS default bucket (string)
        """
        return pulumi.get(self, "default_bucket")

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

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

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

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

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


@pulumi.output_type
class CloudCredentialVsphereCredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vcenterPort":
            suggest = "vcenter_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CloudCredentialVsphereCredentialConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CloudCredentialVsphereCredentialConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CloudCredentialVsphereCredentialConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterAgentEnvVar(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: Name of cluster registration token (string)
        :param str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The GKE taint value (string)
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterAksConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "agentDnsPrefix":
            suggest = "agent_dns_prefix"
        elif key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "masterDnsPrefix":
            suggest = "master_dns_prefix"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "sshPublicKeyContents":
            suggest = "ssh_public_key_contents"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "virtualNetwork":
            suggest = "virtual_network"
        elif key == "virtualNetworkResourceGroup":
            suggest = "virtual_network_resource_group"
        elif key == "aadServerAppSecret":
            suggest = "aad_server_app_secret"
        elif key == "aadTenantId":
            suggest = "aad_tenant_id"
        elif key == "addClientAppId":
            suggest = "add_client_app_id"
        elif key == "addServerAppId":
            suggest = "add_server_app_id"
        elif key == "adminUsername":
            suggest = "admin_username"
        elif key == "agentOsDiskSize":
            suggest = "agent_os_disk_size"
        elif key == "agentPoolName":
            suggest = "agent_pool_name"
        elif key == "agentStorageProfile":
            suggest = "agent_storage_profile"
        elif key == "agentVmSize":
            suggest = "agent_vm_size"
        elif key == "authBaseUrl":
            suggest = "auth_base_url"
        elif key == "baseUrl":
            suggest = "base_url"
        elif key == "dnsServiceIp":
            suggest = "dns_service_ip"
        elif key == "dockerBridgeCidr":
            suggest = "docker_bridge_cidr"
        elif key == "enableHttpApplicationRouting":
            suggest = "enable_http_application_routing"
        elif key == "enableMonitoring":
            suggest = "enable_monitoring"
        elif key == "loadBalancerSku":
            suggest = "load_balancer_sku"
        elif key == "logAnalyticsWorkspace":
            suggest = "log_analytics_workspace"
        elif key == "logAnalyticsWorkspaceResourceGroup":
            suggest = "log_analytics_workspace_resource_group"
        elif key == "maxPods":
            suggest = "max_pods"
        elif key == "networkPlugin":
            suggest = "network_plugin"
        elif key == "networkPolicy":
            suggest = "network_policy"
        elif key == "podCidr":
            suggest = "pod_cidr"
        elif key == "serviceCidr":
            suggest = "service_cidr"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAksConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAksConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAksConfig.__key_warning(key)
        return super().get(key, default)

    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[int] = 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[int] = 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,
                 load_balancer_sku: Optional[str] = None,
                 location: Optional[str] = None,
                 log_analytics_workspace: Optional[str] = None,
                 log_analytics_workspace_resource_group: Optional[str] = None,
                 max_pods: Optional[int] = 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,
                 tags: Optional[Sequence[str]] = 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 version that will be used for your master *and* OKE worker nodes (string)
        :param str master_dns_prefix: DNS prefix to use the Kubernetes cluster control pane (string)
        :param str resource_group: The AKS 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 AKS subnet (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 AKS virtual network resource group (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 int agent_os_disk_size: GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the \"agent vm size\" specified. 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: The AKS auth base url (string)
        :param str base_url: The AKS base url (string)
        :param int count: The AKS node pool count. 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 load_balancer_sku: The AKS load balancer sku (string)
        :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 int max_pods: The AKS node pool max pods. Default: `110` (int)
        :param str network_plugin: The AKS network plugin. Required if `imported=false` (string)
        :param str network_policy: The AKS network policy (string)
        :param str pod_cidr: A CIDR IP range from which to assign Kubernetes Pod IPs (string)
        :param str service_cidr: A CIDR IP range from which to assign Kubernetes Service IPs (string)
        :param Mapping[str, Any] tag: Use `tags` argument instead as []string
        :param Sequence[str] tags: The GKE node config tags (List)
        """
        pulumi.set(__self__, "agent_dns_prefix", agent_dns_prefix)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "master_dns_prefix", master_dns_prefix)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "ssh_public_key_contents", ssh_public_key_contents)
        pulumi.set(__self__, "subnet", subnet)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "virtual_network", virtual_network)
        pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)
        if aad_server_app_secret is not None:
            pulumi.set(__self__, "aad_server_app_secret", aad_server_app_secret)
        if aad_tenant_id is not None:
            pulumi.set(__self__, "aad_tenant_id", aad_tenant_id)
        if add_client_app_id is not None:
            pulumi.set(__self__, "add_client_app_id", add_client_app_id)
        if add_server_app_id is not None:
            pulumi.set(__self__, "add_server_app_id", add_server_app_id)
        if admin_username is not None:
            pulumi.set(__self__, "admin_username", admin_username)
        if agent_os_disk_size is not None:
            pulumi.set(__self__, "agent_os_disk_size", agent_os_disk_size)
        if agent_pool_name is not None:
            pulumi.set(__self__, "agent_pool_name", agent_pool_name)
        if agent_storage_profile is not None:
            pulumi.set(__self__, "agent_storage_profile", agent_storage_profile)
        if agent_vm_size is not None:
            pulumi.set(__self__, "agent_vm_size", agent_vm_size)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if dns_service_ip is not None:
            pulumi.set(__self__, "dns_service_ip", dns_service_ip)
        if docker_bridge_cidr is not None:
            pulumi.set(__self__, "docker_bridge_cidr", docker_bridge_cidr)
        if enable_http_application_routing is not None:
            pulumi.set(__self__, "enable_http_application_routing", enable_http_application_routing)
        if enable_monitoring is not None:
            pulumi.set(__self__, "enable_monitoring", enable_monitoring)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if log_analytics_workspace is not None:
            pulumi.set(__self__, "log_analytics_workspace", log_analytics_workspace)
        if log_analytics_workspace_resource_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_resource_group", log_analytics_workspace_resource_group)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="agentDnsPrefix")
    def agent_dns_prefix(self) -> 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 version that will be used for your master *and* OKE worker nodes (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 AKS 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 AKS subnet (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 AKS virtual network resource group (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[int]:
        """
        GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the \"agent vm size\" specified. 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]:
        """
        The AKS auth base url (string)
        """
        return pulumi.get(self, "auth_base_url")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        """
        The AKS base url (string)
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        """
        The AKS node pool count. 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(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        The AKS load balancer sku (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="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[int]:
        """
        The AKS node pool max pods. Default: `110` (int)
        """
        return pulumi.get(self, "max_pods")

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> Optional[str]:
        """
        The AKS network plugin. Required if `imported=false` (string)
        """
        return pulumi.get(self, "network_plugin")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> Optional[str]:
        """
        The AKS network policy (string)
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[str]:
        """
        A CIDR IP range from which to assign Kubernetes Pod IPs (string)
        """
        return pulumi.get(self, "pod_cidr")

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[str]:
        """
        A CIDR IP range from which to assign Kubernetes Service IPs (string)
        """
        return pulumi.get(self, "service_cidr")

    @property
    @pulumi.getter
    def tag(self) -> Optional[Mapping[str, Any]]:
        """
        Use `tags` argument instead as []string
        """
        return pulumi.get(self, "tag")

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


@pulumi.output_type
class ClusterAksConfigV2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudCredentialId":
            suggest = "cloud_credential_id"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "resourceLocation":
            suggest = "resource_location"
        elif key == "authBaseUrl":
            suggest = "auth_base_url"
        elif key == "authorizedIpRanges":
            suggest = "authorized_ip_ranges"
        elif key == "baseUrl":
            suggest = "base_url"
        elif key == "dnsPrefix":
            suggest = "dns_prefix"
        elif key == "httpApplicationRouting":
            suggest = "http_application_routing"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "linuxAdminUsername":
            suggest = "linux_admin_username"
        elif key == "linuxSshPublicKey":
            suggest = "linux_ssh_public_key"
        elif key == "loadBalancerSku":
            suggest = "load_balancer_sku"
        elif key == "logAnalyticsWorkspaceGroup":
            suggest = "log_analytics_workspace_group"
        elif key == "logAnalyticsWorkspaceName":
            suggest = "log_analytics_workspace_name"
        elif key == "networkDnsServiceIp":
            suggest = "network_dns_service_ip"
        elif key == "networkDockerBridgeCidr":
            suggest = "network_docker_bridge_cidr"
        elif key == "networkPlugin":
            suggest = "network_plugin"
        elif key == "networkPodCidr":
            suggest = "network_pod_cidr"
        elif key == "networkPolicy":
            suggest = "network_policy"
        elif key == "networkServiceCidr":
            suggest = "network_service_cidr"
        elif key == "nodePools":
            suggest = "node_pools"
        elif key == "privateCluster":
            suggest = "private_cluster"
        elif key == "virtualNetwork":
            suggest = "virtual_network"
        elif key == "virtualNetworkResourceGroup":
            suggest = "virtual_network_resource_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAksConfigV2. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAksConfigV2.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAksConfigV2.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_credential_id: str,
                 resource_group: str,
                 resource_location: str,
                 auth_base_url: Optional[str] = None,
                 authorized_ip_ranges: Optional[Sequence[str]] = None,
                 base_url: Optional[str] = None,
                 dns_prefix: Optional[str] = None,
                 http_application_routing: Optional[bool] = None,
                 imported: Optional[bool] = None,
                 kubernetes_version: Optional[str] = None,
                 linux_admin_username: Optional[str] = None,
                 linux_ssh_public_key: Optional[str] = None,
                 load_balancer_sku: Optional[str] = None,
                 log_analytics_workspace_group: Optional[str] = None,
                 log_analytics_workspace_name: Optional[str] = None,
                 monitoring: Optional[bool] = None,
                 name: Optional[str] = None,
                 network_dns_service_ip: Optional[str] = None,
                 network_docker_bridge_cidr: Optional[str] = None,
                 network_plugin: Optional[str] = None,
                 network_pod_cidr: Optional[str] = None,
                 network_policy: Optional[str] = None,
                 network_service_cidr: Optional[str] = None,
                 node_pools: Optional[Sequence['outputs.ClusterAksConfigV2NodePool']] = None,
                 private_cluster: Optional[bool] = None,
                 subnet: Optional[str] = None,
                 tags: Optional[Mapping[str, Any]] = None,
                 virtual_network: Optional[str] = None,
                 virtual_network_resource_group: Optional[str] = None):
        """
        :param str cloud_credential_id: The EKS cloud_credential id (string)
        :param str resource_group: The AKS resource group (string)
        :param str resource_location: The AKS resource location (string)
        :param str auth_base_url: The AKS auth base url (string)
        :param Sequence[str] authorized_ip_ranges: The AKS authorized ip ranges (list)
        :param str base_url: The AKS base url (string)
        :param str dns_prefix: The AKS dns prefix. Required if `imported=false` (string)
        :param bool http_application_routing: Enable AKS http application routing? (bool)
        :param bool imported: Is GKE cluster imported? Default: `false` (bool)
        :param str kubernetes_version: The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        :param str linux_admin_username: The AKS linux admin username (string)
        :param str linux_ssh_public_key: The AKS linux ssh public key (string)
        :param str load_balancer_sku: The AKS load balancer sku (string)
        :param str log_analytics_workspace_group: The AKS log analytics workspace group (string)
        :param str log_analytics_workspace_name: The AKS log analytics workspace name (string)
        :param bool monitoring: Is AKS cluster monitoring enabled? (bool)
        :param str name: Name of cluster registration token (string)
        :param str network_dns_service_ip: The AKS network dns service ip (string)
        :param str network_docker_bridge_cidr: The AKS network docker bridge cidr (string)
        :param str network_plugin: The AKS network plugin. Required if `imported=false` (string)
        :param str network_pod_cidr: The AKS network pod cidr (string)
        :param str network_policy: The AKS network policy (string)
        :param str network_service_cidr: The AKS network service cidr (string)
        :param Sequence['ClusterAksConfigV2NodePoolArgs'] node_pools: The GKE cluster node pools. Required for create new cluster (List)
        :param bool private_cluster: Is AKS cluster private? (bool)
        :param str subnet: The AKS subnet (string)
        :param Mapping[str, Any] tags: The GKE node config tags (List)
        :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 AKS virtual network resource group (string)
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "resource_location", resource_location)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if authorized_ip_ranges is not None:
            pulumi.set(__self__, "authorized_ip_ranges", authorized_ip_ranges)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if dns_prefix is not None:
            pulumi.set(__self__, "dns_prefix", dns_prefix)
        if http_application_routing is not None:
            pulumi.set(__self__, "http_application_routing", http_application_routing)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if linux_admin_username is not None:
            pulumi.set(__self__, "linux_admin_username", linux_admin_username)
        if linux_ssh_public_key is not None:
            pulumi.set(__self__, "linux_ssh_public_key", linux_ssh_public_key)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if log_analytics_workspace_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_group", log_analytics_workspace_group)
        if log_analytics_workspace_name is not None:
            pulumi.set(__self__, "log_analytics_workspace_name", log_analytics_workspace_name)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_dns_service_ip is not None:
            pulumi.set(__self__, "network_dns_service_ip", network_dns_service_ip)
        if network_docker_bridge_cidr is not None:
            pulumi.set(__self__, "network_docker_bridge_cidr", network_docker_bridge_cidr)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_pod_cidr is not None:
            pulumi.set(__self__, "network_pod_cidr", network_pod_cidr)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if network_service_cidr is not None:
            pulumi.set(__self__, "network_service_cidr", network_service_cidr)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)
        if private_cluster is not None:
            pulumi.set(__self__, "private_cluster", private_cluster)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if virtual_network is not None:
            pulumi.set(__self__, "virtual_network", virtual_network)
        if virtual_network_resource_group is not None:
            pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)

    @property
    @pulumi.getter(name="cloudCredentialId")
    def cloud_credential_id(self) -> str:
        """
        The EKS cloud_credential id (string)
        """
        return pulumi.get(self, "cloud_credential_id")

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

    @property
    @pulumi.getter(name="resourceLocation")
    def resource_location(self) -> str:
        """
        The AKS resource location (string)
        """
        return pulumi.get(self, "resource_location")

    @property
    @pulumi.getter(name="authBaseUrl")
    def auth_base_url(self) -> Optional[str]:
        """
        The AKS auth base url (string)
        """
        return pulumi.get(self, "auth_base_url")

    @property
    @pulumi.getter(name="authorizedIpRanges")
    def authorized_ip_ranges(self) -> Optional[Sequence[str]]:
        """
        The AKS authorized ip ranges (list)
        """
        return pulumi.get(self, "authorized_ip_ranges")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        """
        The AKS base url (string)
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="dnsPrefix")
    def dns_prefix(self) -> Optional[str]:
        """
        The AKS dns prefix. Required if `imported=false` (string)
        """
        return pulumi.get(self, "dns_prefix")

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

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[str]:
        """
        The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="linuxAdminUsername")
    def linux_admin_username(self) -> Optional[str]:
        """
        The AKS linux admin username (string)
        """
        return pulumi.get(self, "linux_admin_username")

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

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        The AKS load balancer sku (string)
        """
        return pulumi.get(self, "load_balancer_sku")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceGroup")
    def log_analytics_workspace_group(self) -> Optional[str]:
        """
        The AKS log analytics workspace group (string)
        """
        return pulumi.get(self, "log_analytics_workspace_group")

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

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

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

    @property
    @pulumi.getter(name="networkDnsServiceIp")
    def network_dns_service_ip(self) -> Optional[str]:
        """
        The AKS network dns service ip (string)
        """
        return pulumi.get(self, "network_dns_service_ip")

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

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> Optional[str]:
        """
        The AKS network plugin. Required if `imported=false` (string)
        """
        return pulumi.get(self, "network_plugin")

    @property
    @pulumi.getter(name="networkPodCidr")
    def network_pod_cidr(self) -> Optional[str]:
        """
        The AKS network pod cidr (string)
        """
        return pulumi.get(self, "network_pod_cidr")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> Optional[str]:
        """
        The AKS network policy (string)
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="networkServiceCidr")
    def network_service_cidr(self) -> Optional[str]:
        """
        The AKS network service cidr (string)
        """
        return pulumi.get(self, "network_service_cidr")

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Optional[Sequence['outputs.ClusterAksConfigV2NodePool']]:
        """
        The GKE cluster node pools. Required for create new cluster (List)
        """
        return pulumi.get(self, "node_pools")

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

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

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

    @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")

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


@pulumi.output_type
class ClusterAksConfigV2NodePool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZones":
            suggest = "availability_zones"
        elif key == "enableAutoScaling":
            suggest = "enable_auto_scaling"
        elif key == "maxCount":
            suggest = "max_count"
        elif key == "maxPods":
            suggest = "max_pods"
        elif key == "minCount":
            suggest = "min_count"
        elif key == "orchestratorVersion":
            suggest = "orchestrator_version"
        elif key == "osDiskSizeGb":
            suggest = "os_disk_size_gb"
        elif key == "osDiskType":
            suggest = "os_disk_type"
        elif key == "osType":
            suggest = "os_type"
        elif key == "vmSize":
            suggest = "vm_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAksConfigV2NodePool. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAksConfigV2NodePool.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAksConfigV2NodePool.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 availability_zones: Optional[Sequence[str]] = None,
                 count: Optional[int] = None,
                 enable_auto_scaling: Optional[bool] = None,
                 max_count: Optional[int] = None,
                 max_pods: Optional[int] = None,
                 min_count: Optional[int] = None,
                 mode: Optional[str] = None,
                 orchestrator_version: Optional[str] = None,
                 os_disk_size_gb: Optional[int] = None,
                 os_disk_type: Optional[str] = None,
                 os_type: Optional[str] = None,
                 vm_size: Optional[str] = None):
        """
        :param str name: Name of cluster registration token (string)
        :param Sequence[str] availability_zones: The AKS node pool availability zones (list)
        :param int count: The AKS node pool count. Default: `1` (int)
        :param bool enable_auto_scaling: Is AKS node pool auto scaling enabled? Default: `false` (bool)
        :param int max_count: The AKS node pool max count. Required if `enable_auto_scaling=true` (int)
        :param int max_pods: The AKS node pool max pods. Default: `110` (int)
        :param int min_count: The AKS node pool min count. Required if `enable_auto_scaling=true` (int)
        :param str mode: The AKS node group mode. Default: `System` (string)
        :param str orchestrator_version: The AKS node pool orchestrator version (string)
        :param int os_disk_size_gb: The AKS node pool os disk size gb. Default: `128` (int)
        :param str os_disk_type: The AKS node pool os disk type. Default: `Managed` (string)
        :param str os_type: The AKS node pool os type. Default: `Linux` (string)
        :param str vm_size: The AKS node pool orchestrator version (string)
        """
        pulumi.set(__self__, "name", name)
        if availability_zones is not None:
            pulumi.set(__self__, "availability_zones", availability_zones)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if enable_auto_scaling is not None:
            pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
        if max_count is not None:
            pulumi.set(__self__, "max_count", max_count)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if orchestrator_version is not None:
            pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if os_disk_type is not None:
            pulumi.set(__self__, "os_disk_type", os_disk_type)
        if os_type is not None:
            pulumi.set(__self__, "os_type", os_type)
        if vm_size is not None:
            pulumi.set(__self__, "vm_size", vm_size)

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

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

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

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

    @property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> Optional[int]:
        """
        The AKS node pool max count. Required if `enable_auto_scaling=true` (int)
        """
        return pulumi.get(self, "max_count")

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

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

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        The AKS node group mode. Default: `System` (string)
        """
        return pulumi.get(self, "mode")

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

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

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

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

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


@pulumi.output_type
class ClusterAlertGroupRecipient(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notifierId":
            suggest = "notifier_id"
        elif key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "notifierType":
            suggest = "notifier_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlertGroupRecipient. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlertGroupRecipient.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlertGroupRecipient.__key_warning(key)
        return super().get(key, default)

    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 : `"dingtalk" | "msteams" | "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 : `"dingtalk" | "msteams" | "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")


@pulumi.output_type
class ClusterAlertRuleEventRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceKind":
            suggest = "resource_kind"
        elif key == "eventType":
            suggest = "event_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlertRuleEventRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlertRuleEventRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlertRuleEventRule.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterAlertRuleMetricRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdValue":
            suggest = "threshold_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlertRuleMetricRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlertRuleMetricRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlertRuleMetricRule.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterAlertRuleNodeRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuThreshold":
            suggest = "cpu_threshold"
        elif key == "memThreshold":
            suggest = "mem_threshold"
        elif key == "nodeId":
            suggest = "node_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlertRuleNodeRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlertRuleNodeRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlertRuleNodeRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 cpu_threshold: Optional[int] = None,
                 mem_threshold: Optional[int] = 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 int cpu_threshold: Node rule cpu threshold. Default: `70` (int)
        :param int 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[int]:
        """
        Node rule cpu threshold. Default: `70` (int)
        """
        return pulumi.get(self, "cpu_threshold")

    @property
    @pulumi.getter(name="memThreshold")
    def mem_threshold(self) -> Optional[int]:
        """
        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")


@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")


@pulumi.output_type
class ClusterAlterGroupRecipient(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notifierId":
            suggest = "notifier_id"
        elif key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "notifierType":
            suggest = "notifier_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlterGroupRecipient. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlterGroupRecipient.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlterGroupRecipient.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterAlterRuleEventRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceKind":
            suggest = "resource_kind"
        elif key == "eventType":
            suggest = "event_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlterRuleEventRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlterRuleEventRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlterRuleEventRule.__key_warning(key)
        return super().get(key, default)

    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 ClusterAlterRuleMetricRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdValue":
            suggest = "threshold_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlterRuleMetricRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlterRuleMetricRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlterRuleMetricRule.__key_warning(key)
        return super().get(key, default)

    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 ClusterAlterRuleNodeRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuThreshold":
            suggest = "cpu_threshold"
        elif key == "memThreshold":
            suggest = "mem_threshold"
        elif key == "nodeId":
            suggest = "node_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterAlterRuleNodeRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterAlterRuleNodeRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterAlterRuleNodeRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 cpu_threshold: Optional[int] = None,
                 mem_threshold: Optional[int] = 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[int]:
        return pulumi.get(self, "cpu_threshold")

    @property
    @pulumi.getter(name="memThreshold")
    def mem_threshold(self) -> Optional[int]:
        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 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")


@pulumi.output_type
class ClusterClusterAuthEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caCerts":
            suggest = "ca_certs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterClusterAuthEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterClusterAuthEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterClusterAuthEndpoint.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@pulumi.output_type
class ClusterClusterRegistrationToken(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "insecureCommand":
            suggest = "insecure_command"
        elif key == "insecureNodeCommand":
            suggest = "insecure_node_command"
        elif key == "insecureWindowsNodeCommand":
            suggest = "insecure_windows_node_command"
        elif key == "manifestUrl":
            suggest = "manifest_url"
        elif key == "nodeCommand":
            suggest = "node_command"
        elif key == "windowsNodeCommand":
            suggest = "windows_node_command"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterClusterRegistrationToken. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterClusterRegistrationToken.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterClusterRegistrationToken.__key_warning(key)
        return super().get(key, default)

    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,
                 insecure_node_command: Optional[str] = None,
                 insecure_windows_node_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: The EKS node group launch template ID (string)
        :param str insecure_command: Insecure command to execute in a imported k8s cluster (string)
        :param str insecure_node_command: Insecure node command to execute in a imported k8s cluster (string)
        :param str insecure_windows_node_command: Insecure windows 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 insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if manifest_url is not None:
            pulumi.set(__self__, "manifest_url", manifest_url)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_command is not None:
            pulumi.set(__self__, "node_command", node_command)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if windows_node_command is not None:
            pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[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]:
        """
        The EKS node group launch template ID (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(name="insecureNodeCommand")
    def insecure_node_command(self) -> Optional[str]:
        """
        Insecure node command to execute in a imported k8s cluster (string)
        """
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> Optional[str]:
        """
        Insecure windows command to execute in a imported k8s cluster (string)
        """
        return pulumi.get(self, "insecure_windows_node_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")


@pulumi.output_type
class ClusterClusterTemplateAnswers(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "projectId":
            suggest = "project_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterClusterTemplateAnswers. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterClusterTemplateAnswers.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterClusterTemplateAnswers.__key_warning(key)
        return super().get(key, default)

    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")


@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`, `password`, 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`, `password`, and `string` are allowed. Default `string` (string)
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ClusterEksConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "associateWorkerNodePublicIp":
            suggest = "associate_worker_node_public_ip"
        elif key == "desiredNodes":
            suggest = "desired_nodes"
        elif key == "ebsEncryption":
            suggest = "ebs_encryption"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "keyPairName":
            suggest = "key_pair_name"
        elif key == "maximumNodes":
            suggest = "maximum_nodes"
        elif key == "minimumNodes":
            suggest = "minimum_nodes"
        elif key == "nodeVolumeSize":
            suggest = "node_volume_size"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "serviceRole":
            suggest = "service_role"
        elif key == "sessionToken":
            suggest = "session_token"
        elif key == "userData":
            suggest = "user_data"
        elif key == "virtualNetwork":
            suggest = "virtual_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterEksConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterEksConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterEksConfig.__key_warning(key)
        return super().get(key, default)

    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[int] = None,
                 ebs_encryption: Optional[bool] = None,
                 instance_type: Optional[str] = None,
                 key_pair_name: Optional[str] = None,
                 maximum_nodes: Optional[int] = None,
                 minimum_nodes: Optional[int] = None,
                 node_volume_size: Optional[int] = None,
                 region: Optional[str] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 service_role: Optional[str] = None,
                 session_token: Optional[str] = None,
                 subnets: Optional[Sequence[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 version that will be used for your master *and* OKE worker nodes (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 int desired_nodes: The desired number of worker nodes. Just for Rancher v2.3.x and above. Default `3` (int)
        :param str instance_type: The EKS node group instance type. Default: `t3.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 int maximum_nodes: The maximum number of worker nodes. Default `3` (int)
        :param int minimum_nodes: The minimum number of worker nodes. Default `1` (int)
        :param int node_volume_size: The volume size for each node. Default `20` (int)
        :param str region: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        :param Sequence[str] security_groups: List of security groups to use for the cluster (list)
        :param str service_role: The AWS service role to use (string)
        :param str session_token: A session token to use with the client key and secret if applicable (string)
        :param Sequence[str] subnets: The EKS node group subnets (list string)
        :param str user_data: The EKS node group user data (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 ebs_encryption is not None:
            pulumi.set(__self__, "ebs_encryption", ebs_encryption)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if key_pair_name is not None:
            pulumi.set(__self__, "key_pair_name", key_pair_name)
        if maximum_nodes is not None:
            pulumi.set(__self__, "maximum_nodes", maximum_nodes)
        if minimum_nodes is not None:
            pulumi.set(__self__, "minimum_nodes", minimum_nodes)
        if node_volume_size is not None:
            pulumi.set(__self__, "node_volume_size", node_volume_size)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if service_role is not None:
            pulumi.set(__self__, "service_role", service_role)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if virtual_network is not None:
            pulumi.set(__self__, "virtual_network", virtual_network)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> 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 version that will be used for your master *and* OKE worker nodes (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[int]:
        """
        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="ebsEncryption")
    def ebs_encryption(self) -> Optional[bool]:
        return pulumi.get(self, "ebs_encryption")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        The EKS node group instance type. Default: `t3.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[int]:
        """
        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[int]:
        """
        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[int]:
        """
        The volume size for each node. Default `20` (int)
        """
        return pulumi.get(self, "node_volume_size")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="serviceRole")
    def service_role(self) -> Optional[str]:
        """
        The AWS service role to use (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[Sequence[str]]:
        """
        The EKS node group subnets (list string)
        """
        return pulumi.get(self, "subnets")

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


@pulumi.output_type
class ClusterEksConfigV2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudCredentialId":
            suggest = "cloud_credential_id"
        elif key == "kmsKey":
            suggest = "kms_key"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "loggingTypes":
            suggest = "logging_types"
        elif key == "nodeGroups":
            suggest = "node_groups"
        elif key == "privateAccess":
            suggest = "private_access"
        elif key == "publicAccess":
            suggest = "public_access"
        elif key == "publicAccessSources":
            suggest = "public_access_sources"
        elif key == "secretsEncryption":
            suggest = "secrets_encryption"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "serviceRole":
            suggest = "service_role"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterEksConfigV2. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterEksConfigV2.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterEksConfigV2.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_credential_id: str,
                 imported: Optional[bool] = None,
                 kms_key: Optional[str] = None,
                 kubernetes_version: Optional[str] = None,
                 logging_types: Optional[Sequence[str]] = None,
                 name: Optional[str] = None,
                 node_groups: Optional[Sequence['outputs.ClusterEksConfigV2NodeGroup']] = None,
                 private_access: Optional[bool] = None,
                 public_access: Optional[bool] = None,
                 public_access_sources: Optional[Sequence[str]] = None,
                 region: Optional[str] = None,
                 secrets_encryption: Optional[bool] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 service_role: Optional[str] = None,
                 subnets: Optional[Sequence[str]] = None,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str cloud_credential_id: The EKS cloud_credential id (string)
        :param bool imported: Is GKE cluster imported? Default: `false` (bool)
        :param str kms_key: The AWS kms key to use (string)
        :param str kubernetes_version: The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        :param Sequence[str] logging_types: The AWS cloudwatch logging types. `audit`, `api`, `scheduler`, `controllerManager` and `authenticator` values are allowed (list)
        :param str name: Name of cluster registration token (string)
        :param Sequence['ClusterEksConfigV2NodeGroupArgs'] node_groups: The EKS cluster name to import. Required to create a new cluster (list)
        :param bool private_access: The EKS cluster has private access (bool)
        :param bool public_access: The EKS cluster has public access (bool)
        :param Sequence[str] public_access_sources: The EKS cluster public access sources (map)
        :param str region: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        :param bool secrets_encryption: Enable EKS cluster secret encryption (bool)
        :param Sequence[str] security_groups: List of security groups to use for the cluster (list)
        :param str service_role: The AWS service role to use (string)
        :param Sequence[str] subnets: The EKS node group subnets (list string)
        :param Mapping[str, Any] tags: The GKE node config tags (List)
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if logging_types is not None:
            pulumi.set(__self__, "logging_types", logging_types)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_groups is not None:
            pulumi.set(__self__, "node_groups", node_groups)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if public_access_sources is not None:
            pulumi.set(__self__, "public_access_sources", public_access_sources)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secrets_encryption is not None:
            pulumi.set(__self__, "secrets_encryption", secrets_encryption)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if service_role is not None:
            pulumi.set(__self__, "service_role", service_role)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="cloudCredentialId")
    def cloud_credential_id(self) -> str:
        """
        The EKS cloud_credential id (string)
        """
        return pulumi.get(self, "cloud_credential_id")

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

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[str]:
        """
        The AWS kms key to use (string)
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[str]:
        """
        The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="loggingTypes")
    def logging_types(self) -> Optional[Sequence[str]]:
        """
        The AWS cloudwatch logging types. `audit`, `api`, `scheduler`, `controllerManager` and `authenticator` values are allowed (list)
        """
        return pulumi.get(self, "logging_types")

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

    @property
    @pulumi.getter(name="nodeGroups")
    def node_groups(self) -> Optional[Sequence['outputs.ClusterEksConfigV2NodeGroup']]:
        """
        The EKS cluster name to import. Required to create a new cluster (list)
        """
        return pulumi.get(self, "node_groups")

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

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

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

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        """
        return pulumi.get(self, "region")

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

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

    @property
    @pulumi.getter(name="serviceRole")
    def service_role(self) -> Optional[str]:
        """
        The AWS service role to use (string)
        """
        return pulumi.get(self, "service_role")

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

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


@pulumi.output_type
class ClusterEksConfigV2NodeGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "desiredSize":
            suggest = "desired_size"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "ec2SshKey":
            suggest = "ec2_ssh_key"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "launchTemplates":
            suggest = "launch_templates"
        elif key == "maxSize":
            suggest = "max_size"
        elif key == "minSize":
            suggest = "min_size"
        elif key == "requestSpotInstances":
            suggest = "request_spot_instances"
        elif key == "resourceTags":
            suggest = "resource_tags"
        elif key == "spotInstanceTypes":
            suggest = "spot_instance_types"
        elif key == "userData":
            suggest = "user_data"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterEksConfigV2NodeGroup. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterEksConfigV2NodeGroup.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterEksConfigV2NodeGroup.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 desired_size: Optional[int] = None,
                 disk_size: Optional[int] = None,
                 ec2_ssh_key: Optional[str] = None,
                 gpu: Optional[bool] = None,
                 image_id: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 launch_templates: Optional[Sequence['outputs.ClusterEksConfigV2NodeGroupLaunchTemplate']] = None,
                 max_size: Optional[int] = None,
                 min_size: Optional[int] = None,
                 request_spot_instances: Optional[bool] = None,
                 resource_tags: Optional[Mapping[str, Any]] = None,
                 spot_instance_types: Optional[Sequence[str]] = None,
                 subnets: Optional[Sequence[str]] = None,
                 tags: Optional[Mapping[str, Any]] = None,
                 user_data: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str name: Name of cluster registration token (string)
        :param int desired_size: The EKS node group desired size. Default: `2` (int)
        :param int disk_size: The EKS node group disk size (Gb). Default: `20` (int)
        :param str ec2_ssh_key: The EKS node group ssh key (string)
        :param bool gpu: Set true to EKS use gpu. Default: `false` (bool)
        :param str image_id: The EKS node group image ID (string)
        :param str instance_type: The EKS node group instance type. Default: `t3.medium` (string)
        :param Mapping[str, Any] labels: Labels for cluster registration token object (map)
        :param Sequence['ClusterEksConfigV2NodeGroupLaunchTemplateArgs'] launch_templates: The EKS node groups launch template (list Maxitem: 1)
        :param int max_size: The EKS node group maximum size. Default `2` (int)
        :param int min_size: The EKS node group maximum size. Default `2` (int)
        :param bool request_spot_instances: Enable EKS node group request spot instances (bool)
        :param Mapping[str, Any] resource_tags: The EKS node group resource tags (map)
        :param Sequence[str] spot_instance_types: The EKS node group sport instace types (list string)
        :param Sequence[str] subnets: The EKS node group subnets (list string)
        :param Mapping[str, Any] tags: The GKE node config tags (List)
        :param str user_data: The EKS node group user data (string)
        :param str version: rancher-monitoring chart version (string)
        """
        pulumi.set(__self__, "name", name)
        if desired_size is not None:
            pulumi.set(__self__, "desired_size", desired_size)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if ec2_ssh_key is not None:
            pulumi.set(__self__, "ec2_ssh_key", ec2_ssh_key)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if launch_templates is not None:
            pulumi.set(__self__, "launch_templates", launch_templates)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if request_spot_instances is not None:
            pulumi.set(__self__, "request_spot_instances", request_spot_instances)
        if resource_tags is not None:
            pulumi.set(__self__, "resource_tags", resource_tags)
        if spot_instance_types is not None:
            pulumi.set(__self__, "spot_instance_types", spot_instance_types)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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

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

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

    @property
    @pulumi.getter
    def gpu(self) -> Optional[bool]:
        """
        Set true to EKS use gpu. Default: `false` (bool)
        """
        return pulumi.get(self, "gpu")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        """
        The EKS node group image ID (string)
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        The EKS node group instance type. Default: `t3.medium` (string)
        """
        return pulumi.get(self, "instance_type")

    @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="launchTemplates")
    def launch_templates(self) -> Optional[Sequence['outputs.ClusterEksConfigV2NodeGroupLaunchTemplate']]:
        """
        The EKS node groups launch template (list Maxitem: 1)
        """
        return pulumi.get(self, "launch_templates")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[str]:
        """
        The EKS node group user data (string)
        """
        return pulumi.get(self, "user_data")

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


@pulumi.output_type
class ClusterEksConfigV2NodeGroupLaunchTemplate(dict):
    def __init__(__self__, *,
                 id: str,
                 name: Optional[str] = None,
                 version: Optional[int] = None):
        """
        :param str id: The EKS node group launch template ID (string)
        :param str name: Name of cluster registration token (string)
        :param int version: rancher-monitoring chart version (string)
        """
        pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The EKS node group launch template ID (string)
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class ClusterGkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterIpv4Cidr":
            suggest = "cluster_ipv4_cidr"
        elif key == "diskType":
            suggest = "disk_type"
        elif key == "imageType":
            suggest = "image_type"
        elif key == "ipPolicyClusterIpv4CidrBlock":
            suggest = "ip_policy_cluster_ipv4_cidr_block"
        elif key == "ipPolicyClusterSecondaryRangeName":
            suggest = "ip_policy_cluster_secondary_range_name"
        elif key == "ipPolicyNodeIpv4CidrBlock":
            suggest = "ip_policy_node_ipv4_cidr_block"
        elif key == "ipPolicyServicesIpv4CidrBlock":
            suggest = "ip_policy_services_ipv4_cidr_block"
        elif key == "ipPolicyServicesSecondaryRangeName":
            suggest = "ip_policy_services_secondary_range_name"
        elif key == "ipPolicySubnetworkName":
            suggest = "ip_policy_subnetwork_name"
        elif key == "machineType":
            suggest = "machine_type"
        elif key == "maintenanceWindow":
            suggest = "maintenance_window"
        elif key == "masterIpv4CidrBlock":
            suggest = "master_ipv4_cidr_block"
        elif key == "masterVersion":
            suggest = "master_version"
        elif key == "nodePool":
            suggest = "node_pool"
        elif key == "nodeVersion":
            suggest = "node_version"
        elif key == "oauthScopes":
            suggest = "oauth_scopes"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "serviceAccount":
            suggest = "service_account"
        elif key == "subNetwork":
            suggest = "sub_network"
        elif key == "diskSizeGb":
            suggest = "disk_size_gb"
        elif key == "enableAlphaFeature":
            suggest = "enable_alpha_feature"
        elif key == "enableAutoRepair":
            suggest = "enable_auto_repair"
        elif key == "enableAutoUpgrade":
            suggest = "enable_auto_upgrade"
        elif key == "enableHorizontalPodAutoscaling":
            suggest = "enable_horizontal_pod_autoscaling"
        elif key == "enableHttpLoadBalancing":
            suggest = "enable_http_load_balancing"
        elif key == "enableKubernetesDashboard":
            suggest = "enable_kubernetes_dashboard"
        elif key == "enableLegacyAbac":
            suggest = "enable_legacy_abac"
        elif key == "enableMasterAuthorizedNetwork":
            suggest = "enable_master_authorized_network"
        elif key == "enableNetworkPolicyConfig":
            suggest = "enable_network_policy_config"
        elif key == "enableNodepoolAutoscaling":
            suggest = "enable_nodepool_autoscaling"
        elif key == "enablePrivateEndpoint":
            suggest = "enable_private_endpoint"
        elif key == "enablePrivateNodes":
            suggest = "enable_private_nodes"
        elif key == "enableStackdriverLogging":
            suggest = "enable_stackdriver_logging"
        elif key == "enableStackdriverMonitoring":
            suggest = "enable_stackdriver_monitoring"
        elif key == "ipPolicyCreateSubnetwork":
            suggest = "ip_policy_create_subnetwork"
        elif key == "issueClientCertificate":
            suggest = "issue_client_certificate"
        elif key == "kubernetesDashboard":
            suggest = "kubernetes_dashboard"
        elif key == "localSsdCount":
            suggest = "local_ssd_count"
        elif key == "masterAuthorizedNetworkCidrBlocks":
            suggest = "master_authorized_network_cidr_blocks"
        elif key == "maxNodeCount":
            suggest = "max_node_count"
        elif key == "minNodeCount":
            suggest = "min_node_count"
        elif key == "nodeCount":
            suggest = "node_count"
        elif key == "resourceLabels":
            suggest = "resource_labels"
        elif key == "useIpAliases":
            suggest = "use_ip_aliases"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfig.__key_warning(key)
        return super().get(key, default)

    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: Sequence[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: Sequence[str],
                 project_id: str,
                 service_account: str,
                 sub_network: str,
                 description: Optional[str] = None,
                 disk_size_gb: Optional[int] = 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[int] = None,
                 master_authorized_network_cidr_blocks: Optional[Sequence[str]] = None,
                 max_node_count: Optional[int] = None,
                 min_node_count: Optional[int] = None,
                 node_count: Optional[int] = None,
                 preemptible: Optional[bool] = None,
                 region: Optional[str] = None,
                 resource_labels: Optional[Mapping[str, Any]] = None,
                 taints: Optional[Sequence[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: The GKE node config disk type (string)
        :param str image_type: The GKE node config image type (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 Sequence[str] locations: The GKE cluster locations (List)
        :param str machine_type: The GKE node config machine type (string)
        :param str maintenance_window: The GKE cluster maintenance window (string)
        :param str master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block (string)
        :param str master_version: Master version for GKE cluster (string)
        :param str network: The GKE cluster network. Required for create new 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 Sequence[str] oauth_scopes: The GKE node config oauth scopes (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 int disk_size_gb: The GKE node config disk size Gb (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: Specifies 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_master_authorized_network: Enable master authorized network. Set to `true` if `master_authorized_network_cidr_blocks` is set. 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: Enable GKE cluster private endpoint. Default: `false` (bool)
        :param bool enable_private_nodes: Specifies whether worker nodes will be deployed into a new, private, subnet. 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 int local_ssd_count: The GKE node config local ssd count (int)
        :param Sequence[str] master_authorized_network_cidr_blocks: Define up to 10 external networks that could access Kubernetes master through HTTPS (list)
        :param int max_node_count: The GKE node pool config max node count (int)
        :param int min_node_count: The GKE node pool config min node count (int)
        :param int node_count: Node count for GKE cluster. Default `3` (int)
        :param bool preemptible: Enable GKE node config preemptible. Default: `false` (bool)
        :param str region: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        :param Mapping[str, Any] resource_labels: The map of Kubernetes labels to be applied to each cluster (map)
        :param Sequence[str] taints: The GKE node config taints (List)
        :param bool use_ip_aliases: Use GKE ip aliases? Default: `true` (bool)
        :param str zone: The GKE cluster zone. Required if `region` not set (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:
        """
        The GKE node config disk type (string)
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> str:
        """
        The GKE node config image type (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) -> Sequence[str]:
        """
        The GKE cluster locations (List)
        """
        return pulumi.get(self, "locations")

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

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

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> str:
        """
        The GKE cluster private master ip v4 cidr block (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:
        """
        The GKE cluster network. Required for create new 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) -> Sequence[str]:
        """
        The GKE node config oauth scopes (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[int]:
        """
        The GKE node config disk size Gb (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]:
        """
        Specifies 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]:
        """
        Enable master authorized network. Set to `true` if `master_authorized_network_cidr_blocks` is set. Default `false` (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]:
        """
        Enable GKE cluster private endpoint. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[bool]:
        """
        Specifies whether worker nodes will be deployed into a new, private, subnet. 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[int]:
        """
        The GKE node config local ssd count (int)
        """
        return pulumi.get(self, "local_ssd_count")

    @property
    @pulumi.getter(name="masterAuthorizedNetworkCidrBlocks")
    def master_authorized_network_cidr_blocks(self) -> Optional[Sequence[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[int]:
        """
        The GKE node pool config max node count (int)
        """
        return pulumi.get(self, "max_node_count")

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

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

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

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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[Sequence[str]]:
        """
        The GKE node config taints (List)
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[bool]:
        """
        Use GKE ip aliases? Default: `true` (bool)
        """
        return pulumi.get(self, "use_ip_aliases")

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


@pulumi.output_type
class ClusterGkeConfigV2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "googleCredentialSecret":
            suggest = "google_credential_secret"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "clusterAddons":
            suggest = "cluster_addons"
        elif key == "clusterIpv4CidrBlock":
            suggest = "cluster_ipv4_cidr_block"
        elif key == "enableKubernetesAlpha":
            suggest = "enable_kubernetes_alpha"
        elif key == "ipAllocationPolicy":
            suggest = "ip_allocation_policy"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "loggingService":
            suggest = "logging_service"
        elif key == "maintenanceWindow":
            suggest = "maintenance_window"
        elif key == "masterAuthorizedNetworksConfig":
            suggest = "master_authorized_networks_config"
        elif key == "monitoringService":
            suggest = "monitoring_service"
        elif key == "networkPolicyEnabled":
            suggest = "network_policy_enabled"
        elif key == "nodePools":
            suggest = "node_pools"
        elif key == "privateClusterConfig":
            suggest = "private_cluster_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 google_credential_secret: str,
                 name: str,
                 project_id: str,
                 cluster_addons: Optional['outputs.ClusterGkeConfigV2ClusterAddons'] = None,
                 cluster_ipv4_cidr_block: Optional[str] = None,
                 description: Optional[str] = None,
                 enable_kubernetes_alpha: Optional[bool] = None,
                 imported: Optional[bool] = None,
                 ip_allocation_policy: Optional['outputs.ClusterGkeConfigV2IpAllocationPolicy'] = None,
                 kubernetes_version: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 locations: Optional[Sequence[str]] = None,
                 logging_service: Optional[str] = None,
                 maintenance_window: Optional[str] = None,
                 master_authorized_networks_config: Optional['outputs.ClusterGkeConfigV2MasterAuthorizedNetworksConfig'] = None,
                 monitoring_service: Optional[str] = None,
                 network: Optional[str] = None,
                 network_policy_enabled: Optional[bool] = None,
                 node_pools: Optional[Sequence['outputs.ClusterGkeConfigV2NodePool']] = None,
                 private_cluster_config: Optional['outputs.ClusterGkeConfigV2PrivateClusterConfig'] = None,
                 region: Optional[str] = None,
                 subnetwork: Optional[str] = None,
                 zone: Optional[str] = None):
        """
        :param str google_credential_secret: Google credential secret (string)
        :param str name: Name of cluster registration token (string)
        :param str project_id: Project ID to apply answer (string)
        :param 'ClusterGkeConfigV2ClusterAddonsArgs' cluster_addons: The GKE cluster addons (List maxitems:1)
        :param str cluster_ipv4_cidr_block: The GKE cluster ip v4 allocation cidr block (string)
        :param str description: An optional description of this cluster (string)
        :param bool enable_kubernetes_alpha: Enable Kubernetes alpha. Default: `false` (bool)
        :param bool imported: Is GKE cluster imported? Default: `false` (bool)
        :param 'ClusterGkeConfigV2IpAllocationPolicyArgs' ip_allocation_policy: The GKE ip allocation policy (List maxitems:1)
        :param str kubernetes_version: The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        :param Mapping[str, Any] labels: Labels for cluster registration token object (map)
        :param Sequence[str] locations: The GKE cluster locations (List)
        :param str logging_service: The GKE cluster logging service (string)
        :param str maintenance_window: The GKE cluster maintenance window (string)
        :param 'ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs' master_authorized_networks_config: The GKE cluster master authorized networks config (List maxitems:1)
        :param str monitoring_service: The GKE cluster monitoring service (string)
        :param str network: The GKE cluster network. Required for create new cluster (string)
        :param bool network_policy_enabled: Is GKE cluster network policy enabled? Default: `false` (bool)
        :param Sequence['ClusterGkeConfigV2NodePoolArgs'] node_pools: The GKE cluster node pools. Required for create new cluster (List)
        :param 'ClusterGkeConfigV2PrivateClusterConfigArgs' private_cluster_config: The GKE private cluster config (List maxitems:1)
        :param str region: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        :param str subnetwork: The GKE cluster subnetwork. Required for create new cluster (string)
        :param str zone: The GKE cluster zone. Required if `region` not set (string)
        """
        pulumi.set(__self__, "google_credential_secret", google_credential_secret)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "project_id", project_id)
        if cluster_addons is not None:
            pulumi.set(__self__, "cluster_addons", cluster_addons)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_alpha is not None:
            pulumi.set(__self__, "enable_kubernetes_alpha", enable_kubernetes_alpha)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if ip_allocation_policy is not None:
            pulumi.set(__self__, "ip_allocation_policy", ip_allocation_policy)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if logging_service is not None:
            pulumi.set(__self__, "logging_service", logging_service)
        if maintenance_window is not None:
            pulumi.set(__self__, "maintenance_window", maintenance_window)
        if master_authorized_networks_config is not None:
            pulumi.set(__self__, "master_authorized_networks_config", master_authorized_networks_config)
        if monitoring_service is not None:
            pulumi.set(__self__, "monitoring_service", monitoring_service)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_policy_enabled is not None:
            pulumi.set(__self__, "network_policy_enabled", network_policy_enabled)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)
        if private_cluster_config is not None:
            pulumi.set(__self__, "private_cluster_config", private_cluster_config)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

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

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

    @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="clusterAddons")
    def cluster_addons(self) -> Optional['outputs.ClusterGkeConfigV2ClusterAddons']:
        """
        The GKE cluster addons (List maxitems:1)
        """
        return pulumi.get(self, "cluster_addons")

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

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

    @property
    @pulumi.getter(name="enableKubernetesAlpha")
    def enable_kubernetes_alpha(self) -> Optional[bool]:
        """
        Enable Kubernetes alpha. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_kubernetes_alpha")

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

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[str]:
        """
        The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @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
    def locations(self) -> Optional[Sequence[str]]:
        """
        The GKE cluster locations (List)
        """
        return pulumi.get(self, "locations")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Optional[Sequence['outputs.ClusterGkeConfigV2NodePool']]:
        """
        The GKE cluster node pools. Required for create new cluster (List)
        """
        return pulumi.get(self, "node_pools")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        """
        return pulumi.get(self, "region")

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

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


@pulumi.output_type
class ClusterGkeConfigV2ClusterAddons(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "horizontalPodAutoscaling":
            suggest = "horizontal_pod_autoscaling"
        elif key == "httpLoadBalancing":
            suggest = "http_load_balancing"
        elif key == "networkPolicyConfig":
            suggest = "network_policy_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2ClusterAddons. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2ClusterAddons.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2ClusterAddons.__key_warning(key)
        return super().get(key, default)

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

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

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

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


@pulumi.output_type
class ClusterGkeConfigV2IpAllocationPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterIpv4CidrBlock":
            suggest = "cluster_ipv4_cidr_block"
        elif key == "clusterSecondaryRangeName":
            suggest = "cluster_secondary_range_name"
        elif key == "createSubnetwork":
            suggest = "create_subnetwork"
        elif key == "nodeIpv4CidrBlock":
            suggest = "node_ipv4_cidr_block"
        elif key == "servicesIpv4CidrBlock":
            suggest = "services_ipv4_cidr_block"
        elif key == "servicesSecondaryRangeName":
            suggest = "services_secondary_range_name"
        elif key == "subnetworkName":
            suggest = "subnetwork_name"
        elif key == "useIpAliases":
            suggest = "use_ip_aliases"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2IpAllocationPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2IpAllocationPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2IpAllocationPolicy.__key_warning(key)
        return super().get(key, default)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[bool]:
        """
        Use GKE ip aliases? Default: `true` (bool)
        """
        return pulumi.get(self, "use_ip_aliases")


@pulumi.output_type
class ClusterGkeConfigV2MasterAuthorizedNetworksConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cidrBlocks":
            suggest = "cidr_blocks"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2MasterAuthorizedNetworksConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2MasterAuthorizedNetworksConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2MasterAuthorizedNetworksConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cidr_blocks: Sequence['outputs.ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock'],
                 enabled: Optional[bool] = None):
        """
        :param Sequence['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs'] cidr_blocks: The GKE master authorized network config cidr blocks (List)
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        """
        pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

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


@pulumi.output_type
class ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cidrBlock":
            suggest = "cidr_block"
        elif key == "displayName":
            suggest = "display_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock.__key_warning(key)
        return super().get(key, default)

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

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

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


@pulumi.output_type
class ClusterGkeConfigV2NodePool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "initialNodeCount":
            suggest = "initial_node_count"
        elif key == "maxPodsConstraint":
            suggest = "max_pods_constraint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2NodePool. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2NodePool.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2NodePool.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 initial_node_count: int,
                 name: str,
                 version: str,
                 autoscaling: Optional['outputs.ClusterGkeConfigV2NodePoolAutoscaling'] = None,
                 config: Optional['outputs.ClusterGkeConfigV2NodePoolConfig'] = None,
                 management: Optional['outputs.ClusterGkeConfigV2NodePoolManagement'] = None,
                 max_pods_constraint: Optional[int] = None):
        """
        :param int initial_node_count: The GKE node pool config initial node count (int)
        :param str name: Name of cluster registration token (string)
        :param str version: rancher-monitoring chart version (string)
        :param 'ClusterGkeConfigV2NodePoolAutoscalingArgs' autoscaling: The GKE node pool config autoscaling (List maxitems:1)
        :param 'ClusterGkeConfigV2NodePoolConfigArgs' config: The GKE node pool node config (List maxitems:1)
        :param 'ClusterGkeConfigV2NodePoolManagementArgs' management: The GKE node pool config management (List maxitems:1)
        :param int max_pods_constraint: The GKE node pool config max pods constraint. Required for create new cluster if `ip_allocation_policy.use_ip_aliases = true` (int)
        """
        pulumi.set(__self__, "initial_node_count", initial_node_count)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, "max_pods_constraint", max_pods_constraint)

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

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

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

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional['outputs.ClusterGkeConfigV2NodePoolAutoscaling']:
        """
        The GKE node pool config autoscaling (List maxitems:1)
        """
        return pulumi.get(self, "autoscaling")

    @property
    @pulumi.getter
    def config(self) -> Optional['outputs.ClusterGkeConfigV2NodePoolConfig']:
        """
        The GKE node pool node config (List maxitems:1)
        """
        return pulumi.get(self, "config")

    @property
    @pulumi.getter
    def management(self) -> Optional['outputs.ClusterGkeConfigV2NodePoolManagement']:
        """
        The GKE node pool config management (List maxitems:1)
        """
        return pulumi.get(self, "management")

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> Optional[int]:
        """
        The GKE node pool config max pods constraint. Required for create new cluster if `ip_allocation_policy.use_ip_aliases = true` (int)
        """
        return pulumi.get(self, "max_pods_constraint")


@pulumi.output_type
class ClusterGkeConfigV2NodePoolAutoscaling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxNodeCount":
            suggest = "max_node_count"
        elif key == "minNodeCount":
            suggest = "min_node_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2NodePoolAutoscaling. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2NodePoolAutoscaling.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2NodePoolAutoscaling.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 max_node_count: Optional[int] = None,
                 min_node_count: Optional[int] = None):
        """
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        :param int max_node_count: The GKE node pool config max node count (int)
        :param int min_node_count: The GKE node pool config min node count (int)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if max_node_count is not None:
            pulumi.set(__self__, "max_node_count", max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, "min_node_count", min_node_count)

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

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

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


@pulumi.output_type
class ClusterGkeConfigV2NodePoolConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskSizeGb":
            suggest = "disk_size_gb"
        elif key == "diskType":
            suggest = "disk_type"
        elif key == "imageType":
            suggest = "image_type"
        elif key == "localSsdCount":
            suggest = "local_ssd_count"
        elif key == "machineType":
            suggest = "machine_type"
        elif key == "oauthScopes":
            suggest = "oauth_scopes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2NodePoolConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2NodePoolConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2NodePoolConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disk_size_gb: Optional[int] = None,
                 disk_type: Optional[str] = None,
                 image_type: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 local_ssd_count: Optional[int] = None,
                 machine_type: Optional[str] = None,
                 oauth_scopes: Optional[Sequence[str]] = None,
                 preemptible: Optional[bool] = None,
                 tags: Optional[Sequence[str]] = None,
                 taints: Optional[Sequence['outputs.ClusterGkeConfigV2NodePoolConfigTaint']] = None):
        """
        :param int disk_size_gb: The GKE node config disk size Gb (int)
        :param str disk_type: The GKE node config disk type (string)
        :param str image_type: The GKE node config image type (string)
        :param Mapping[str, Any] labels: Labels for cluster registration token object (map)
        :param int local_ssd_count: The GKE node config local ssd count (int)
        :param str machine_type: The GKE node config machine type (string)
        :param Sequence[str] oauth_scopes: The GKE node config oauth scopes (List)
        :param bool preemptible: Enable GKE node config preemptible. Default: `false` (bool)
        :param Sequence[str] tags: The GKE node config tags (List)
        :param Sequence['ClusterGkeConfigV2NodePoolConfigTaintArgs'] taints: The GKE node config taints (List)
        """
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

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

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

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

    @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[int]:
        """
        The GKE node config local ssd count (int)
        """
        return pulumi.get(self, "local_ssd_count")

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

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

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

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

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


@pulumi.output_type
class ClusterGkeConfigV2NodePoolConfigTaint(dict):
    def __init__(__self__, *,
                 effect: str,
                 key: str,
                 value: str):
        """
        :param str effect: The GKE taint effect (string)
        :param str key: The GKE taint key (string)
        :param str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> str:
        """
        The GKE taint effect (string)
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The GKE taint value (string)
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterGkeConfigV2NodePoolManagement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoRepair":
            suggest = "auto_repair"
        elif key == "autoUpgrade":
            suggest = "auto_upgrade"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2NodePoolManagement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2NodePoolManagement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2NodePoolManagement.__key_warning(key)
        return super().get(key, default)

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

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

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


@pulumi.output_type
class ClusterGkeConfigV2PrivateClusterConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "masterIpv4CidrBlock":
            suggest = "master_ipv4_cidr_block"
        elif key == "enablePrivateEndpoint":
            suggest = "enable_private_endpoint"
        elif key == "enablePrivateNodes":
            suggest = "enable_private_nodes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeConfigV2PrivateClusterConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterGkeConfigV2PrivateClusterConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterGkeConfigV2PrivateClusterConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 master_ipv4_cidr_block: str,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None):
        """
        :param str master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block (string)
        :param bool enable_private_endpoint: Enable GKE cluster private endpoint. Default: `false` (bool)
        :param bool enable_private_nodes: Specifies whether worker nodes will be deployed into a new, private, subnet. Default `false` (bool)
        """
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> str:
        """
        The GKE cluster private master ip v4 cidr block (string)
        """
        return pulumi.get(self, "master_ipv4_cidr_block")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[bool]:
        """
        Enable GKE cluster private endpoint. Default: `false` (bool)
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[bool]:
        """
        Specifies whether worker nodes will be deployed into a new, private, subnet. Default `false` (bool)
        """
        return pulumi.get(self, "enable_private_nodes")


@pulumi.output_type
class ClusterK3sConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "upgradeStrategy":
            suggest = "upgrade_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterK3sConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterK3sConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterK3sConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterK3sConfigUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "drainServerNodes":
            suggest = "drain_server_nodes"
        elif key == "drainWorkerNodes":
            suggest = "drain_worker_nodes"
        elif key == "serverConcurrency":
            suggest = "server_concurrency"
        elif key == "workerConcurrency":
            suggest = "worker_concurrency"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterK3sConfigUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterK3sConfigUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterK3sConfigUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

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

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


@pulumi.output_type
class ClusterLoggingCustomTargetConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingCustomTargetConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingCustomTargetConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingCustomTargetConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterLoggingElasticsearchConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authPassword":
            suggest = "auth_password"
        elif key == "authUsername":
            suggest = "auth_username"
        elif key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "clientKeyPass":
            suggest = "client_key_pass"
        elif key == "dateFormat":
            suggest = "date_format"
        elif key == "indexPrefix":
            suggest = "index_prefix"
        elif key == "sslVerify":
            suggest = "ssl_verify"
        elif key == "sslVersion":
            suggest = "ssl_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingElasticsearchConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingElasticsearchConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingElasticsearchConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterLoggingFluentdConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fluentServers":
            suggest = "fluent_servers"
        elif key == "enableTls":
            suggest = "enable_tls"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingFluentdConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingFluentdConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingFluentdConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fluent_servers: Sequence['outputs.ClusterLoggingFluentdConfigFluentServer'],
                 certificate: Optional[str] = None,
                 compress: Optional[bool] = None,
                 enable_tls: Optional[bool] = None):
        """
        :param Sequence['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) -> Sequence['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")


@pulumi.output_type
class ClusterLoggingFluentdConfigFluentServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sharedKey":
            suggest = "shared_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingFluentdConfigFluentServer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingFluentdConfigFluentServer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingFluentdConfigFluentServer.__key_warning(key)
        return super().get(key, default)

    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[int] = 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 int 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[int]:
        """
        Weight of the fluentd server (int)
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class ClusterLoggingKafkaConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "brokerEndpoints":
            suggest = "broker_endpoints"
        elif key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "zookeeperEndpoint":
            suggest = "zookeeper_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingKafkaConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingKafkaConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingKafkaConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 topic: str,
                 broker_endpoints: Optional[Sequence[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 Sequence[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[Sequence[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")


@pulumi.output_type
class ClusterLoggingSplunkConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "clientKeyPass":
            suggest = "client_key_pass"
        elif key == "sslVerify":
            suggest = "ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingSplunkConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingSplunkConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingSplunkConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterLoggingSyslogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "enableTls":
            suggest = "enable_tls"
        elif key == "sslVerify":
            suggest = "ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLoggingSyslogConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLoggingSyslogConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLoggingSyslogConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterOkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compartmentId":
            suggest = "compartment_id"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "nodeImage":
            suggest = "node_image"
        elif key == "nodeShape":
            suggest = "node_shape"
        elif key == "privateKeyContents":
            suggest = "private_key_contents"
        elif key == "tenancyId":
            suggest = "tenancy_id"
        elif key == "userOcid":
            suggest = "user_ocid"
        elif key == "customBootVolumeSize":
            suggest = "custom_boot_volume_size"
        elif key == "enableKubernetesDashboard":
            suggest = "enable_kubernetes_dashboard"
        elif key == "enablePrivateControlPlane":
            suggest = "enable_private_control_plane"
        elif key == "enablePrivateNodes":
            suggest = "enable_private_nodes"
        elif key == "flexOcpus":
            suggest = "flex_ocpus"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"
        elif key == "limitNodeCount":
            suggest = "limit_node_count"
        elif key == "loadBalancerSubnetName1":
            suggest = "load_balancer_subnet_name1"
        elif key == "loadBalancerSubnetName2":
            suggest = "load_balancer_subnet_name2"
        elif key == "nodePoolDnsDomainName":
            suggest = "node_pool_dns_domain_name"
        elif key == "nodePoolSubnetName":
            suggest = "node_pool_subnet_name"
        elif key == "nodePublicKeyContents":
            suggest = "node_public_key_contents"
        elif key == "podCidr":
            suggest = "pod_cidr"
        elif key == "privateKeyPassphrase":
            suggest = "private_key_passphrase"
        elif key == "quantityOfNodeSubnets":
            suggest = "quantity_of_node_subnets"
        elif key == "quantityPerSubnet":
            suggest = "quantity_per_subnet"
        elif key == "serviceCidr":
            suggest = "service_cidr"
        elif key == "serviceDnsDomainName":
            suggest = "service_dns_domain_name"
        elif key == "skipVcnDelete":
            suggest = "skip_vcn_delete"
        elif key == "vcnCompartmentId":
            suggest = "vcn_compartment_id"
        elif key == "vcnName":
            suggest = "vcn_name"
        elif key == "workerNodeIngressCidr":
            suggest = "worker_node_ingress_cidr"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterOkeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterOkeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterOkeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 compartment_id: str,
                 fingerprint: str,
                 kubernetes_version: str,
                 node_image: str,
                 node_shape: str,
                 private_key_contents: str,
                 region: str,
                 tenancy_id: str,
                 user_ocid: str,
                 custom_boot_volume_size: Optional[int] = None,
                 description: Optional[str] = None,
                 enable_kubernetes_dashboard: Optional[bool] = None,
                 enable_private_control_plane: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None,
                 flex_ocpus: Optional[int] = None,
                 kms_key_id: Optional[str] = None,
                 limit_node_count: Optional[int] = None,
                 load_balancer_subnet_name1: Optional[str] = None,
                 load_balancer_subnet_name2: Optional[str] = None,
                 node_pool_dns_domain_name: Optional[str] = None,
                 node_pool_subnet_name: Optional[str] = None,
                 node_public_key_contents: Optional[str] = None,
                 pod_cidr: Optional[str] = None,
                 private_key_passphrase: Optional[str] = None,
                 quantity_of_node_subnets: Optional[int] = None,
                 quantity_per_subnet: Optional[int] = None,
                 service_cidr: Optional[str] = None,
                 service_dns_domain_name: Optional[str] = None,
                 skip_vcn_delete: Optional[bool] = None,
                 vcn_compartment_id: Optional[str] = None,
                 vcn_name: Optional[str] = None,
                 worker_node_ingress_cidr: Optional[str] = None):
        """
        :param str compartment_id: The OCID of the compartment in which to create resources OKE cluster and related resources (string)
        :param str fingerprint: The fingerprint corresponding to the specified user's private API Key (string)
        :param str kubernetes_version: The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        :param str node_image: The Oracle Linux OS image name to use for the OKE node(s). See [here](https://docs.cloud.oracle.com/en-us/iaas/images/) for a list of images. (string)
        :param str node_shape: The shape of the node (determines number of CPUs and  amount of memory on each OKE node) (string)
        :param str private_key_contents: The private API key file contents for the specified user, in PEM format (string)
        :param str region: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        :param str tenancy_id: The OCID of the tenancy in which to create resources (string)
        :param str user_ocid: The OCID of a user who has access to the tenancy/compartment (string)
        :param int custom_boot_volume_size: Optional custom boot volume size (GB) for all nodes. If you specify 0, it will apply the default according to the `node_image` specified. Default `0` (int)
        :param str description: An optional description of this cluster (string)
        :param bool enable_kubernetes_dashboard: Specifies whether to enable the Kubernetes dashboard. Default `false` (bool)
        :param bool enable_private_control_plane: Specifies whether Kubernetes API endpoint is a private IP only accessible from within the VCN. Default `false` Just for Rancher v2.5.10 or above (bool)
        :param bool enable_private_nodes: Specifies whether worker nodes will be deployed into a new, private, subnet. Default `false` (bool)
        :param int flex_ocpus: Specifies number of OCPUs for nodes (requires flexible shape specified with `node_shape`) (int)
        :param str kms_key_id: The OCID of a KMS vault master key used to encrypt secrets at rest. See [here](https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contengencryptingdata.htm) for help creating a vault and master encryption key. Just for Rancher v2.5.9 or above (string)
        :param int limit_node_count: The maximum number of worker nodes. Can limit `quantity_per_subnet`. Default `0` (no limit) (int)
        :param str load_balancer_subnet_name1: The name of the first existing subnet to use for Kubernetes services / LB. `vcn_name` is also required when specifying an existing subnet. (string)
        :param str load_balancer_subnet_name2: The name of a second existing subnet to use for Kubernetes services / LB. A second subnet is only required when it is AD-specific (non-regional) (string)
        :param str node_pool_dns_domain_name: Name for DNS domain of node pool subnet. Default `nodedns` (string)
        :param str node_pool_subnet_name: Name for node pool subnet. Default `nodedns` (string)
        :param str node_public_key_contents: The contents of the SSH public key file to use for the nodes (string)
        :param str pod_cidr: A CIDR IP range from which to assign Kubernetes Pod IPs (string)
        :param str private_key_passphrase: The passphrase (if any) of the private key for the OKE cluster (string)
        :param int quantity_of_node_subnets: Number of node subnets. Default `1` (int)
        :param int quantity_per_subnet: Number of OKE worker nodes in each subnet / availability domain. Default `1` (int)
        :param str service_cidr: A CIDR IP range from which to assign Kubernetes Service IPs (string)
        :param str service_dns_domain_name: Name for DNS domain of service subnet. Default `svcdns` (string)
        :param bool skip_vcn_delete: Specifies whether to skip deleting the virtual cloud network (VCN) on destroy. Default `false` (bool)
        :param str vcn_compartment_id: The OCID of the compartment (if different from `compartment_id`) in which to find the pre-existing virtual network set with `vcn_name`. (string)
        :param str vcn_name: The name of an existing virtual network to use for the cluster creation. If set, you must also set `load_balancer_subnet_name_1`. A VCN and subnets will be created if none are specified. (string)
        :param str worker_node_ingress_cidr: Additional CIDR from which to allow ingress to worker nodes (string)
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "fingerprint", fingerprint)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "node_image", node_image)
        pulumi.set(__self__, "node_shape", node_shape)
        pulumi.set(__self__, "private_key_contents", private_key_contents)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenancy_id", tenancy_id)
        pulumi.set(__self__, "user_ocid", user_ocid)
        if custom_boot_volume_size is not None:
            pulumi.set(__self__, "custom_boot_volume_size", custom_boot_volume_size)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_dashboard is not None:
            pulumi.set(__self__, "enable_kubernetes_dashboard", enable_kubernetes_dashboard)
        if enable_private_control_plane is not None:
            pulumi.set(__self__, "enable_private_control_plane", enable_private_control_plane)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if flex_ocpus is not None:
            pulumi.set(__self__, "flex_ocpus", flex_ocpus)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if limit_node_count is not None:
            pulumi.set(__self__, "limit_node_count", limit_node_count)
        if load_balancer_subnet_name1 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name1", load_balancer_subnet_name1)
        if load_balancer_subnet_name2 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name2", load_balancer_subnet_name2)
        if node_pool_dns_domain_name is not None:
            pulumi.set(__self__, "node_pool_dns_domain_name", node_pool_dns_domain_name)
        if node_pool_subnet_name is not None:
            pulumi.set(__self__, "node_pool_subnet_name", node_pool_subnet_name)
        if node_public_key_contents is not None:
            pulumi.set(__self__, "node_public_key_contents", node_public_key_contents)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if private_key_passphrase is not None:
            pulumi.set(__self__, "private_key_passphrase", private_key_passphrase)
        if quantity_of_node_subnets is not None:
            pulumi.set(__self__, "quantity_of_node_subnets", quantity_of_node_subnets)
        if quantity_per_subnet is not None:
            pulumi.set(__self__, "quantity_per_subnet", quantity_per_subnet)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)
        if service_dns_domain_name is not None:
            pulumi.set(__self__, "service_dns_domain_name", service_dns_domain_name)
        if skip_vcn_delete is not None:
            pulumi.set(__self__, "skip_vcn_delete", skip_vcn_delete)
        if vcn_compartment_id is not None:
            pulumi.set(__self__, "vcn_compartment_id", vcn_compartment_id)
        if vcn_name is not None:
            pulumi.set(__self__, "vcn_name", vcn_name)
        if worker_node_ingress_cidr is not None:
            pulumi.set(__self__, "worker_node_ingress_cidr", worker_node_ingress_cidr)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The OCID of the compartment in which to create resources OKE cluster and related resources (string)
        """
        return pulumi.get(self, "compartment_id")

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        """
        The Kubernetes version that will be used for your master *and* OKE worker nodes (string)
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="nodeImage")
    def node_image(self) -> str:
        """
        The Oracle Linux OS image name to use for the OKE node(s). See [here](https://docs.cloud.oracle.com/en-us/iaas/images/) for a list of images. (string)
        """
        return pulumi.get(self, "node_image")

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

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

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
        """
        return pulumi.get(self, "region")

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

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

    @property
    @pulumi.getter(name="customBootVolumeSize")
    def custom_boot_volume_size(self) -> Optional[int]:
        """
        Optional custom boot volume size (GB) for all nodes. If you specify 0, it will apply the default according to the `node_image` specified. Default `0` (int)
        """
        return pulumi.get(self, "custom_boot_volume_size")

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

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

    @property
    @pulumi.getter(name="enablePrivateControlPlane")
    def enable_private_control_plane(self) -> Optional[bool]:
        """
        Specifies whether Kubernetes API endpoint is a private IP only accessible from within the VCN. Default `false` Just for Rancher v2.5.10 or above (bool)
        """
        return pulumi.get(self, "enable_private_control_plane")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[bool]:
        """
        Specifies whether worker nodes will be deployed into a new, private, subnet. Default `false` (bool)
        """
        return pulumi.get(self, "enable_private_nodes")

    @property
    @pulumi.getter(name="flexOcpus")
    def flex_ocpus(self) -> Optional[int]:
        """
        Specifies number of OCPUs for nodes (requires flexible shape specified with `node_shape`) (int)
        """
        return pulumi.get(self, "flex_ocpus")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[str]:
        """
        The OCID of a KMS vault master key used to encrypt secrets at rest. See [here](https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contengencryptingdata.htm) for help creating a vault and master encryption key. Just for Rancher v2.5.9 or above (string)
        """
        return pulumi.get(self, "kms_key_id")

    @property
    @pulumi.getter(name="limitNodeCount")
    def limit_node_count(self) -> Optional[int]:
        """
        The maximum number of worker nodes. Can limit `quantity_per_subnet`. Default `0` (no limit) (int)
        """
        return pulumi.get(self, "limit_node_count")

    @property
    @pulumi.getter(name="loadBalancerSubnetName1")
    def load_balancer_subnet_name1(self) -> Optional[str]:
        """
        The name of the first existing subnet to use for Kubernetes services / LB. `vcn_name` is also required when specifying an existing subnet. (string)
        """
        return pulumi.get(self, "load_balancer_subnet_name1")

    @property
    @pulumi.getter(name="loadBalancerSubnetName2")
    def load_balancer_subnet_name2(self) -> Optional[str]:
        """
        The name of a second existing subnet to use for Kubernetes services / LB. A second subnet is only required when it is AD-specific (non-regional) (string)
        """
        return pulumi.get(self, "load_balancer_subnet_name2")

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

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

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

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[str]:
        """
        A CIDR IP range from which to assign Kubernetes Pod IPs (string)
        """
        return pulumi.get(self, "pod_cidr")

    @property
    @pulumi.getter(name="privateKeyPassphrase")
    def private_key_passphrase(self) -> Optional[str]:
        """
        The passphrase (if any) of the private key for the OKE cluster (string)
        """
        return pulumi.get(self, "private_key_passphrase")

    @property
    @pulumi.getter(name="quantityOfNodeSubnets")
    def quantity_of_node_subnets(self) -> Optional[int]:
        """
        Number of node subnets. Default `1` (int)
        """
        return pulumi.get(self, "quantity_of_node_subnets")

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

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[str]:
        """
        A CIDR IP range from which to assign Kubernetes Service IPs (string)
        """
        return pulumi.get(self, "service_cidr")

    @property
    @pulumi.getter(name="serviceDnsDomainName")
    def service_dns_domain_name(self) -> Optional[str]:
        """
        Name for DNS domain of service subnet. Default `svcdns` (string)
        """
        return pulumi.get(self, "service_dns_domain_name")

    @property
    @pulumi.getter(name="skipVcnDelete")
    def skip_vcn_delete(self) -> Optional[bool]:
        """
        Specifies whether to skip deleting the virtual cloud network (VCN) on destroy. Default `false` (bool)
        """
        return pulumi.get(self, "skip_vcn_delete")

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

    @property
    @pulumi.getter(name="vcnName")
    def vcn_name(self) -> Optional[str]:
        """
        The name of an existing virtual network to use for the cluster creation. If set, you must also set `load_balancer_subnet_name_1`. A VCN and subnets will be created if none are specified. (string)
        """
        return pulumi.get(self, "vcn_name")

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


@pulumi.output_type
class ClusterRke2Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "upgradeStrategy":
            suggest = "upgrade_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRke2Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRke2Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRke2Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 upgrade_strategy: Optional['outputs.ClusterRke2ConfigUpgradeStrategy'] = None,
                 version: Optional[str] = None):
        """
        :param 'ClusterRke2ConfigUpgradeStrategyArgs' 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.ClusterRke2ConfigUpgradeStrategy']:
        """
        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")


@pulumi.output_type
class ClusterRke2ConfigUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "drainServerNodes":
            suggest = "drain_server_nodes"
        elif key == "drainWorkerNodes":
            suggest = "drain_worker_nodes"
        elif key == "serverConcurrency":
            suggest = "server_concurrency"
        elif key == "workerConcurrency":
            suggest = "worker_concurrency"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRke2ConfigUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRke2ConfigUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRke2ConfigUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

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

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


@pulumi.output_type
class ClusterRkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "addonJobTimeout":
            suggest = "addon_job_timeout"
        elif key == "addonsIncludes":
            suggest = "addons_includes"
        elif key == "bastionHost":
            suggest = "bastion_host"
        elif key == "cloudProvider":
            suggest = "cloud_provider"
        elif key == "enableCriDockerd":
            suggest = "enable_cri_dockerd"
        elif key == "ignoreDockerVersion":
            suggest = "ignore_docker_version"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "prefixPath":
            suggest = "prefix_path"
        elif key == "privateRegistries":
            suggest = "private_registries"
        elif key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshCertPath":
            suggest = "ssh_cert_path"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"
        elif key == "upgradeStrategy":
            suggest = "upgrade_strategy"
        elif key == "winPrefixPath":
            suggest = "win_prefix_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 addon_job_timeout: Optional[int] = None,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[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,
                 enable_cri_dockerd: Optional[bool] = 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[Sequence['outputs.ClusterRkeConfigNode']] = None,
                 prefix_path: Optional[str] = None,
                 private_registries: Optional[Sequence['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,
                 win_prefix_path: Optional[str] = None):
        """
        :param int addon_job_timeout: Duration in seconds of addon job (int)
        :param str addons: Addons descripton to deploy on RKE cluster.
        :param Sequence[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 enable_cri_dockerd: Enable/disable using cri-dockerd. Deafult: `false` [enable_cri_dockerd](https://rancher.com/docs/rke/latest/en/config-options/#cri-dockerd) (bool)
        :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 version that will be used for your master *and* OKE worker nodes (string)
        :param 'ClusterRkeConfigMonitoringArgs' monitoring: Is AKS cluster monitoring enabled? (bool)
        :param 'ClusterRkeConfigNetworkArgs' network: The GKE cluster network. Required for create new cluster (string)
        :param Sequence['ClusterRkeConfigNodeArgs'] nodes: RKE cluster nodes (list)
        :param str prefix_path: Prefix to customize Kubernetes path (string)
        :param Sequence['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)
        :param str win_prefix_path: Prefix to customize Kubernetes path for windows (string)
        """
        if addon_job_timeout is not None:
            pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if bastion_host is not None:
            pulumi.set(__self__, "bastion_host", bastion_host)
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if win_prefix_path is not None:
            pulumi.set(__self__, "win_prefix_path", win_prefix_path)

    @property
    @pulumi.getter(name="addonJobTimeout")
    def addon_job_timeout(self) -> Optional[int]:
        """
        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[Sequence[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="enableCriDockerd")
    def enable_cri_dockerd(self) -> Optional[bool]:
        """
        Enable/disable using cri-dockerd. Deafult: `false` [enable_cri_dockerd](https://rancher.com/docs/rke/latest/en/config-options/#cri-dockerd) (bool)
        """
        return pulumi.get(self, "enable_cri_dockerd")

    @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 version that will be used for your master *and* OKE worker nodes (string)
        """
        return pulumi.get(self, "kubernetes_version")

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

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

    @property
    @pulumi.getter
    def nodes(self) -> Optional[Sequence['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[Sequence['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")

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


@pulumi.output_type
class ClusterRkeConfigAuthentication(dict):
    def __init__(__self__, *,
                 sans: Optional[Sequence[str]] = None,
                 strategy: Optional[str] = None):
        """
        :param Sequence[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[Sequence[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")


@pulumi.output_type
class ClusterRkeConfigAuthorization(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None,
                 options: Optional[Mapping[str, Any]] = None):
        """
        :param str mode: The AKS node group mode. Default: `System` (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]:
        """
        The AKS node group mode. Default: `System` (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")


@pulumi.output_type
class ClusterRkeConfigBastionHost(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshKey":
            suggest = "ssh_key"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigBastionHost. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigBastionHost.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigBastionHost.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsCloudProvider":
            suggest = "aws_cloud_provider"
        elif key == "azureCloudProvider":
            suggest = "azure_cloud_provider"
        elif key == "customCloudProvider":
            suggest = "custom_cloud_provider"
        elif key == "openstackCloudProvider":
            suggest = "openstack_cloud_provider"
        elif key == "vsphereCloudProvider":
            suggest = "vsphere_cloud_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProvider.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderAwsCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "global":
            suggest = "global_"
        elif key == "serviceOverrides":
            suggest = "service_overrides"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderAwsCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderAwsCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderAwsCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 global_: Optional['outputs.ClusterRkeConfigCloudProviderAwsCloudProviderGlobal'] = None,
                 service_overrides: Optional[Sequence['outputs.ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride']] = None):
        """
        :param 'ClusterRkeConfigCloudProviderAwsCloudProviderGlobalArgs' global_: (list maxitems:1)
        :param Sequence['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[Sequence['outputs.ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride']]:
        """
        (list)
        """
        return pulumi.get(self, "service_overrides")


@pulumi.output_type
class ClusterRkeConfigCloudProviderAwsCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableSecurityGroupIngress":
            suggest = "disable_security_group_ingress"
        elif key == "disableStrictZoneCheck":
            suggest = "disable_strict_zone_check"
        elif key == "elbSecurityGroup":
            suggest = "elb_security_group"
        elif key == "kubernetesClusterId":
            suggest = "kubernetes_cluster_id"
        elif key == "kubernetesClusterTag":
            suggest = "kubernetes_cluster_tag"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "routeTableId":
            suggest = "route_table_id"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderAwsCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderAwsCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderAwsCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    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: The GKE cluster zone. Required if `region` not set (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]:
        """
        The GKE cluster zone. Required if `region` not set (string)
        """
        return pulumi.get(self, "zone")


@pulumi.output_type
class ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "signingMethod":
            suggest = "signing_method"
        elif key == "signingName":
            suggest = "signing_name"
        elif key == "signingRegion":
            suggest = "signing_region"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride.__key_warning(key)
        return super().get(key, default)

    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: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderAzureCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aadClientId":
            suggest = "aad_client_id"
        elif key == "aadClientSecret":
            suggest = "aad_client_secret"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "aadClientCertPassword":
            suggest = "aad_client_cert_password"
        elif key == "aadClientCertPath":
            suggest = "aad_client_cert_path"
        elif key == "cloudProviderBackoff":
            suggest = "cloud_provider_backoff"
        elif key == "cloudProviderBackoffDuration":
            suggest = "cloud_provider_backoff_duration"
        elif key == "cloudProviderBackoffExponent":
            suggest = "cloud_provider_backoff_exponent"
        elif key == "cloudProviderBackoffJitter":
            suggest = "cloud_provider_backoff_jitter"
        elif key == "cloudProviderBackoffRetries":
            suggest = "cloud_provider_backoff_retries"
        elif key == "cloudProviderRateLimit":
            suggest = "cloud_provider_rate_limit"
        elif key == "cloudProviderRateLimitBucket":
            suggest = "cloud_provider_rate_limit_bucket"
        elif key == "cloudProviderRateLimitQps":
            suggest = "cloud_provider_rate_limit_qps"
        elif key == "loadBalancerSku":
            suggest = "load_balancer_sku"
        elif key == "maximumLoadBalancerRuleCount":
            suggest = "maximum_load_balancer_rule_count"
        elif key == "primaryAvailabilitySetName":
            suggest = "primary_availability_set_name"
        elif key == "primaryScaleSetName":
            suggest = "primary_scale_set_name"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "routeTableName":
            suggest = "route_table_name"
        elif key == "securityGroupName":
            suggest = "security_group_name"
        elif key == "subnetName":
            suggest = "subnet_name"
        elif key == "useInstanceMetadata":
            suggest = "use_instance_metadata"
        elif key == "useManagedIdentityExtension":
            suggest = "use_managed_identity_extension"
        elif key == "vmType":
            suggest = "vm_type"
        elif key == "vnetName":
            suggest = "vnet_name"
        elif key == "vnetResourceGroup":
            suggest = "vnet_resource_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderAzureCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderAzureCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderAzureCloudProvider.__key_warning(key)
        return super().get(key, default)

    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[int] = None,
                 cloud_provider_backoff_exponent: Optional[int] = None,
                 cloud_provider_backoff_jitter: Optional[int] = None,
                 cloud_provider_backoff_retries: Optional[int] = None,
                 cloud_provider_rate_limit: Optional[bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[int] = None,
                 cloud_provider_rate_limit_qps: Optional[int] = None,
                 load_balancer_sku: Optional[str] = None,
                 location: Optional[str] = None,
                 maximum_load_balancer_rule_count: Optional[int] = 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 int cloud_provider_backoff_duration: (int)
        :param int cloud_provider_backoff_exponent: (int)
        :param int cloud_provider_backoff_jitter: (int)
        :param int cloud_provider_backoff_retries: (int)
        :param bool cloud_provider_rate_limit: (bool)
        :param int cloud_provider_rate_limit_bucket: (int)
        :param int cloud_provider_rate_limit_qps: (int)
        :param str load_balancer_sku: The AKS load balancer sku (string)
        :param str location: Azure Kubernetes cluster location. Default `eastus` (string)
        :param int 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 AKS 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[int]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_backoff_duration")

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

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

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> Optional[int]:
        """
        (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[int]:
        """
        (int)
        """
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

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

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        The AKS load balancer sku (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[int]:
        """
        (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 AKS 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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "global":
            suggest = "global_"
        elif key == "blockStorage":
            suggest = "block_storage"
        elif key == "loadBalancer":
            suggest = "load_balancer"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderOpenstackCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProvider.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bsVersion":
            suggest = "bs_version"
        elif key == "ignoreVolumeAz":
            suggest = "ignore_volume_az"
        elif key == "trustDevicePath":
            suggest = "trust_device_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "caFile":
            suggest = "ca_file"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "trustId":
            suggest = "trust_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    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: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createMonitor":
            suggest = "create_monitor"
        elif key == "floatingNetworkId":
            suggest = "floating_network_id"
        elif key == "lbMethod":
            suggest = "lb_method"
        elif key == "lbProvider":
            suggest = "lb_provider"
        elif key == "lbVersion":
            suggest = "lb_version"
        elif key == "manageSecurityGroups":
            suggest = "manage_security_groups"
        elif key == "monitorDelay":
            suggest = "monitor_delay"
        elif key == "monitorMaxRetries":
            suggest = "monitor_max_retries"
        elif key == "monitorTimeout":
            suggest = "monitor_timeout"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "useOctavia":
            suggest = "use_octavia"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer.__key_warning(key)
        return super().get(key, default)

    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[int] = 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 int 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[int]:
        """
        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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestTimeout":
            suggest = "request_timeout"
        elif key == "searchOrder":
            suggest = "search_order"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_timeout: Optional[int] = None,
                 search_order: Optional[str] = None):
        """
        :param int 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[int]:
        """
        (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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "routerId":
            suggest = "router_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualCenters":
            suggest = "virtual_centers"
        elif key == "global":
            suggest = "global_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderVsphereCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 virtual_centers: Sequence['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter'],
                 workspace: 'outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace',
                 disk: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderDisk'] = None,
                 global_: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal'] = None,
                 network: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork'] = None):
        """
        :param Sequence['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: The GKE cluster network. Required for create new 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) -> Sequence['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']:
        """
        The GKE cluster network. Required for create new cluster (string)
        """
        return pulumi.get(self, "network")


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scsiControllerType":
            suggest = "scsi_controller_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderVsphereCloudProviderDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderDisk.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "insecureFlag":
            suggest = "insecure_flag"
        elif key == "soapRoundtripCount":
            suggest = "soap_roundtrip_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 datacenters: Optional[str] = None,
                 insecure_flag: Optional[bool] = None,
                 password: Optional[str] = None,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = 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 int 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[int]:
        """
        (int)
        """
        return pulumi.get(self, "soap_roundtrip_count")

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


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "publicNetwork":
            suggest = "public_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "soapRoundtripCount":
            suggest = "soap_roundtrip_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 user: str,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = 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 int 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[int]:
        """
        (int)
        """
        return pulumi.get(self, "soap_roundtrip_count")


@pulumi.output_type
class ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultDatastore":
            suggest = "default_datastore"
        elif key == "resourcepoolPath":
            suggest = "resourcepool_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigDns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "linearAutoscalerParams":
            suggest = "linear_autoscaler_params"
        elif key == "nodeSelector":
            suggest = "node_selector"
        elif key == "reverseCidrs":
            suggest = "reverse_cidrs"
        elif key == "updateStrategy":
            suggest = "update_strategy"
        elif key == "upstreamNameservers":
            suggest = "upstream_nameservers"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigDns. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigDns.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigDns.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 linear_autoscaler_params: Optional['outputs.ClusterRkeConfigDnsLinearAutoscalerParams'] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 nodelocal: Optional['outputs.ClusterRkeConfigDnsNodelocal'] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 reverse_cidrs: Optional[Sequence[str]] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigDnsToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigDnsUpdateStrategy'] = None,
                 upstream_nameservers: Optional[Sequence[str]] = None):
        """
        :param 'ClusterRkeConfigDnsLinearAutoscalerParamsArgs' linear_autoscaler_params: LinearAutoScalerParams dns config (list Maxitem: 1)
        :param Mapping[str, Any] node_selector: RKE monitoring node selector (map)
        :param 'ClusterRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns config  (list Maxitem: 1)
        :param Mapping[str, Any] options: RKE options for network (map)
        :param str provider: RKE monitoring provider (string)
        :param Sequence[str] reverse_cidrs: DNS add-on reverse cidr  (list)
        :param Sequence['ClusterRkeConfigDnsTolerationArgs'] tolerations: Network add-on tolerations (list)
        :param 'ClusterRkeConfigDnsUpdateStrategyArgs' update_strategy: RKE monitoring update strategy (list Maxitems: 1)
        :param Sequence[str] upstream_nameservers: DNS add-on upstream nameservers  (list)
        """
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.ClusterRkeConfigDnsLinearAutoscalerParams']:
        """
        LinearAutoScalerParams dns config (list Maxitem: 1)
        """
        return pulumi.get(self, "linear_autoscaler_params")

    @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 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(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[Sequence[str]]:
        """
        DNS add-on reverse cidr  (list)
        """
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterRkeConfigDnsToleration']]:
        """
        Network add-on tolerations (list)
        """
        return pulumi.get(self, "tolerations")

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

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


@pulumi.output_type
class ClusterRkeConfigDnsLinearAutoscalerParams(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "coresPerReplica":
            suggest = "cores_per_replica"
        elif key == "nodesPerReplica":
            suggest = "nodes_per_replica"
        elif key == "preventSinglePointFailure":
            suggest = "prevent_single_point_failure"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigDnsLinearAutoscalerParams. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigDnsLinearAutoscalerParams.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigDnsLinearAutoscalerParams.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cores_per_replica: Optional[float] = None,
                 max: Optional[int] = None,
                 min: Optional[int] = None,
                 nodes_per_replica: Optional[float] = None,
                 prevent_single_point_failure: Optional[bool] = None):
        """
        :param float cores_per_replica: number of replicas per cluster cores (float64)
        :param int max: maximum number of replicas (int64)
        :param int min: minimum number of replicas (int64)
        :param float nodes_per_replica: number of replica per cluster nodes (float64)
        :param bool prevent_single_point_failure: prevent single point of failure
        """
        if cores_per_replica is not None:
            pulumi.set(__self__, "cores_per_replica", cores_per_replica)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)
        if nodes_per_replica is not None:
            pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
        if prevent_single_point_failure is not None:
            pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)

    @property
    @pulumi.getter(name="coresPerReplica")
    def cores_per_replica(self) -> Optional[float]:
        """
        number of replicas per cluster cores (float64)
        """
        return pulumi.get(self, "cores_per_replica")

    @property
    @pulumi.getter
    def max(self) -> Optional[int]:
        """
        maximum number of replicas (int64)
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional[int]:
        """
        minimum number of replicas (int64)
        """
        return pulumi.get(self, "min")

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[float]:
        """
        number of replica per cluster nodes (float64)
        """
        return pulumi.get(self, "nodes_per_replica")

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


@pulumi.output_type
class ClusterRkeConfigDnsNodelocal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipAddress":
            suggest = "ip_address"
        elif key == "nodeSelector":
            suggest = "node_selector"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigDnsNodelocal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigDnsNodelocal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigDnsNodelocal.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigDnsToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        """
        :param str key: The GKE taint key (string)
        :param str effect: The GKE taint effect (string)
        :param str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param int seconds: The toleration seconds (int)
        :param str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        """
        return pulumi.get(self, "operator")

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

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


@pulumi.output_type
class ClusterRkeConfigDnsUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigDnsUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigDnsUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigDnsUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterRkeConfigDnsUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs' 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.ClusterRkeConfigDnsUpdateStrategyRollingUpdate']:
        """
        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")


@pulumi.output_type
class ClusterRkeConfigDnsUpdateStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"
        elif key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigDnsUpdateStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigDnsUpdateStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigDnsUpdateStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Monitoring deployment rolling update max surge. Default: `1` (int)
        :param int 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[int]:
        """
        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[int]:
        """
        Monitoring deployment rolling update max unavailable. Default: `1` (int)
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class ClusterRkeConfigIngress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultBackend":
            suggest = "default_backend"
        elif key == "dnsPolicy":
            suggest = "dns_policy"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "httpPort":
            suggest = "http_port"
        elif key == "httpsPort":
            suggest = "https_port"
        elif key == "networkMode":
            suggest = "network_mode"
        elif key == "nodeSelector":
            suggest = "node_selector"
        elif key == "updateStrategy":
            suggest = "update_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigIngress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigIngress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigIngress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_backend: Optional[bool] = None,
                 dns_policy: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 http_port: Optional[int] = None,
                 https_port: Optional[int] = None,
                 network_mode: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigIngressToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigIngressUpdateStrategy'] = None):
        """
        :param bool default_backend: Enable ingress default backend. Default: `true` (bool)
        :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 int http_port: HTTP port for RKE Ingress (int)
        :param int https_port: HTTPS port for RKE Ingress (int)
        :param str network_mode: Network mode for RKE Ingress (string)
        :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 Sequence['ClusterRkeConfigIngressTolerationArgs'] tolerations: Network add-on tolerations (list)
        :param 'ClusterRkeConfigIngressUpdateStrategyArgs' update_strategy: RKE monitoring update strategy (list Maxitems: 1)
        """
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if http_port is not None:
            pulumi.set(__self__, "http_port", http_port)
        if https_port is not None:
            pulumi.set(__self__, "https_port", https_port)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="defaultBackend")
    def default_backend(self) -> Optional[bool]:
        """
        Enable ingress default backend. Default: `true` (bool)
        """
        return pulumi.get(self, "default_backend")

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

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

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> Optional[str]:
        """
        Network mode for RKE Ingress (string)
        """
        return pulumi.get(self, "network_mode")

    @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 tolerations(self) -> Optional[Sequence['outputs.ClusterRkeConfigIngressToleration']]:
        """
        Network add-on tolerations (list)
        """
        return pulumi.get(self, "tolerations")

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


@pulumi.output_type
class ClusterRkeConfigIngressToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        """
        :param str key: The GKE taint key (string)
        :param str effect: The GKE taint effect (string)
        :param str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param int seconds: The toleration seconds (int)
        :param str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        """
        return pulumi.get(self, "operator")

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

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


@pulumi.output_type
class ClusterRkeConfigIngressUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigIngressUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigIngressUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigIngressUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterRkeConfigIngressUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs' 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.ClusterRkeConfigIngressUpdateStrategyRollingUpdate']:
        """
        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")


@pulumi.output_type
class ClusterRkeConfigIngressUpdateStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigIngressUpdateStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigIngressUpdateStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigIngressUpdateStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

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

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


@pulumi.output_type
class ClusterRkeConfigMonitoring(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nodeSelector":
            suggest = "node_selector"
        elif key == "updateStrategy":
            suggest = "update_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigMonitoring. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigMonitoring.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigMonitoring.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 replicas: Optional[int] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigMonitoringToleration']] = 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 int replicas: RKE monitoring replicas (int)
        :param Sequence['ClusterRkeConfigMonitoringTolerationArgs'] tolerations: Network add-on tolerations (list)
        :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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[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[int]:
        """
        RKE monitoring replicas (int)
        """
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterRkeConfigMonitoringToleration']]:
        """
        Network add-on tolerations (list)
        """
        return pulumi.get(self, "tolerations")

    @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")


@pulumi.output_type
class ClusterRkeConfigMonitoringToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        """
        :param str key: The GKE taint key (string)
        :param str effect: The GKE taint effect (string)
        :param str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param int seconds: The toleration seconds (int)
        :param str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        """
        return pulumi.get(self, "operator")

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

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


@pulumi.output_type
class ClusterRkeConfigMonitoringUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigMonitoringUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigMonitoringUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigMonitoringUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"
        elif key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Monitoring deployment rolling update max surge. Default: `1` (int)
        :param int 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[int]:
        """
        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[int]:
        """
        Monitoring deployment rolling update max unavailable. Default: `1` (int)
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class ClusterRkeConfigNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "calicoNetworkProvider":
            suggest = "calico_network_provider"
        elif key == "canalNetworkProvider":
            suggest = "canal_network_provider"
        elif key == "flannelNetworkProvider":
            suggest = "flannel_network_provider"
        elif key == "weaveNetworkProvider":
            suggest = "weave_network_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigNetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigNetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigNetwork.__key_warning(key)
        return super().get(key, default)

    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[int] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 plugin: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigNetworkToleration']] = 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 int 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 Sequence['ClusterRkeConfigNetworkTolerationArgs'] tolerations: Network add-on tolerations (list)
        :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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="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[int]:
        """
        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
    def tolerations(self) -> Optional[Sequence['outputs.ClusterRkeConfigNetworkToleration']]:
        """
        Network add-on tolerations (list)
        """
        return pulumi.get(self, "tolerations")

    @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")


@pulumi.output_type
class ClusterRkeConfigNetworkCalicoNetworkProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudProvider":
            suggest = "cloud_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigNetworkCalicoNetworkProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigNetworkCalicoNetworkProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigNetworkCalicoNetworkProvider.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@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")


@pulumi.output_type
class ClusterRkeConfigNetworkToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        """
        :param str key: The GKE taint key (string)
        :param str effect: The GKE taint effect (string)
        :param str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param int seconds: The toleration seconds (int)
        :param str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        """
        return pulumi.get(self, "operator")

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

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


@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")


@pulumi.output_type
class ClusterRkeConfigNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dockerSocket":
            suggest = "docker_socket"
        elif key == "hostnameOverride":
            suggest = "hostname_override"
        elif key == "internalAddress":
            suggest = "internal_address"
        elif key == "nodeId":
            suggest = "node_id"
        elif key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshKey":
            suggest = "ssh_key"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigNode. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigNode.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigNode.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: str,
                 roles: Sequence[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 Sequence[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) -> Sequence[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")


@pulumi.output_type
class ClusterRkeConfigPrivateRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ecrCredentialPlugin":
            suggest = "ecr_credential_plugin"
        elif key == "isDefault":
            suggest = "is_default"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigPrivateRegistry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigPrivateRegistry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigPrivateRegistry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 ecr_credential_plugin: Optional['outputs.ClusterRkeConfigPrivateRegistryEcrCredentialPlugin'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :param str url: Registry URL (string)
        :param 'ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs' ecr_credential_plugin: ECR credential plugin config (list maxitems:1)
        :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 ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

    @property
    @pulumi.getter(name="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional['outputs.ClusterRkeConfigPrivateRegistryEcrCredentialPlugin']:
        """
        ECR credential plugin config (list maxitems:1)
        """
        return pulumi.get(self, "ecr_credential_plugin")

    @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")


@pulumi.output_type
class ClusterRkeConfigPrivateRegistryEcrCredentialPlugin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsAccessKeyId":
            suggest = "aws_access_key_id"
        elif key == "awsSecretAccessKey":
            suggest = "aws_secret_access_key"
        elif key == "awsSessionToken":
            suggest = "aws_session_token"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigPrivateRegistryEcrCredentialPlugin. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigPrivateRegistryEcrCredentialPlugin.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigPrivateRegistryEcrCredentialPlugin.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        """
        :param str aws_access_key_id: AWS access key ID (string)
        :param str aws_secret_access_key: AWS secret access key (string)
        :param str aws_session_token: AWS session token (string)
        """
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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


@pulumi.output_type
class ClusterRkeConfigServices(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kubeApi":
            suggest = "kube_api"
        elif key == "kubeController":
            suggest = "kube_controller"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServices. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServices.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServices.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigServicesEtcd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backupConfig":
            suggest = "backup_config"
        elif key == "caCert":
            suggest = "ca_cert"
        elif key == "externalUrls":
            suggest = "external_urls"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesEtcd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesEtcd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesEtcd.__key_warning(key)
        return super().get(key, default)

    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[Sequence[str]] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 image: Optional[str] = None,
                 key: Optional[str] = None,
                 path: Optional[str] = None,
                 retention: Optional[str] = None,
                 snapshot: Optional[bool] = None,
                 uid: Optional[int] = 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 Sequence[str] external_urls: External urls for etcd service (list)
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[str] extra_envs: Extra environment for scheduler service (list)
        :param int 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: The GKE taint key (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 int 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[Sequence[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[Sequence[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

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

    @property
    @pulumi.getter
    def gid(self) -> Optional[int]:
        """
        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]:
        """
        The GKE taint key (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[int]:
        """
        Etcd service UID. Default: `0`. For Rancher v2.3.x or above (int)
        """
        return pulumi.get(self, "uid")


@pulumi.output_type
class ClusterRkeConfigServicesEtcdBackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalHours":
            suggest = "interval_hours"
        elif key == "s3BackupConfig":
            suggest = "s3_backup_config"
        elif key == "safeTimestamp":
            suggest = "safe_timestamp"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesEtcdBackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesEtcdBackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesEtcdBackupConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None,
                 timeout: Optional[int] = None):
        """
        :param bool enabled: Enable scheduled cluster scan. Default: `false` (bool)
        :param int interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param int 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)
        :param int timeout: RKE node drain timeout. Default: `60` (int)
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        """
        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")

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


@pulumi.output_type
class ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "customCa":
            suggest = "custom_ca"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig.__key_warning(key)
        return super().get(key, default)

    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: The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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]:
        """
        The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (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")


@pulumi.output_type
class ClusterRkeConfigServicesKubeApi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "admissionConfiguration":
            suggest = "admission_configuration"
        elif key == "alwaysPullImages":
            suggest = "always_pull_images"
        elif key == "auditLog":
            suggest = "audit_log"
        elif key == "eventRateLimit":
            suggest = "event_rate_limit"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "podSecurityPolicy":
            suggest = "pod_security_policy"
        elif key == "secretsEncryptionConfig":
            suggest = "secrets_encryption_config"
        elif key == "serviceClusterIpRange":
            suggest = "service_cluster_ip_range"
        elif key == "serviceNodePortRange":
            suggest = "service_node_port_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesKubeApi. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesKubeApi.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesKubeApi.__key_warning(key)
        return super().get(key, default)

    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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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 Sequence[str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[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[Sequence[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@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. [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string) Ex:
        :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. [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string) Ex:
        """
        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")


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiAuditLogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxAge":
            suggest = "max_age"
        elif key == "maxBackup":
            suggest = "max_backup"
        elif key == "maxSize":
            suggest = "max_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesKubeApiAuditLogConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesKubeApiAuditLogConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesKubeApiAuditLogConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 format: Optional[str] = None,
                 max_age: Optional[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = None,
                 path: Optional[str] = None,
                 policy: Optional[str] = None):
        """
        :param str format: Audit log format. Default: 'json' (string)
        :param int max_age: Audit log max age. Default: `30` (int)
        :param int max_backup: Audit log max backup. Default: `10` (int)
        :param int max_size: The EKS node group maximum size. Default `2` (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. [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string) Ex:
        """
        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[int]:
        """
        Audit log max age. Default: `30` (int)
        """
        return pulumi.get(self, "max_age")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        """
        The EKS node group maximum size. Default `2` (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. [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string) Ex:
        """
        return pulumi.get(self, "policy")


@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. [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string) Ex:
        :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. [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string) Ex:
        """
        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")


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customConfig":
            suggest = "custom_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig.__key_warning(key)
        return super().get(key, default)

    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. [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string) Ex:
        :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. [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string) Ex:
        """
        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")


@pulumi.output_type
class ClusterRkeConfigServicesKubeController(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterCidr":
            suggest = "cluster_cidr"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "serviceClusterIpRange":
            suggest = "service_cluster_ip_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesKubeController. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesKubeController.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesKubeController.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_cidr: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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 Sequence[str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[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[Sequence[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@pulumi.output_type
class ClusterRkeConfigServicesKubelet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterDnsServer":
            suggest = "cluster_dns_server"
        elif key == "clusterDomain":
            suggest = "cluster_domain"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "failSwapOn":
            suggest = "fail_swap_on"
        elif key == "generateServingCertificate":
            suggest = "generate_serving_certificate"
        elif key == "infraContainerImage":
            suggest = "infra_container_image"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesKubelet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesKubelet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesKubelet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_dns_server: Optional[str] = None,
                 cluster_domain: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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 Sequence[str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[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[Sequence[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@pulumi.output_type
class ClusterRkeConfigServicesKubeproxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesKubeproxy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesKubeproxy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesKubeproxy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None):
        """
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[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[Sequence[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@pulumi.output_type
class ClusterRkeConfigServicesScheduler(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigServicesScheduler. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigServicesScheduler.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigServicesScheduler.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None):
        """
        :param Mapping[str, Any] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[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[Sequence[str]]:
        """
        Extra binds for scheduler service (list)
        """
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@pulumi.output_type
class ClusterRkeConfigUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "drainInput":
            suggest = "drain_input"
        elif key == "maxUnavailableControlplane":
            suggest = "max_unavailable_controlplane"
        elif key == "maxUnavailableWorker":
            suggest = "max_unavailable_worker"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterRkeConfigUpgradeStrategyDrainInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteLocalData":
            suggest = "delete_local_data"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "ignoreDaemonSets":
            suggest = "ignore_daemon_sets"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterRkeConfigUpgradeStrategyDrainInput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterRkeConfigUpgradeStrategyDrainInput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterRkeConfigUpgradeStrategyDrainInput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = 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 int grace_period: RKE node drain grace period. Default: `-1` (int)
        :param bool ignore_daemon_sets: Ignore RKE daemon sets. Default: `true` (bool)
        :param int 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[int]:
        """
        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[int]:
        """
        RKE node drain timeout. Default: `60` (int)
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class ClusterScheduledClusterScan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scanConfig":
            suggest = "scan_config"
        elif key == "scheduleConfig":
            suggest = "schedule_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterScheduledClusterScan. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterScheduledClusterScan.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterScheduledClusterScan.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterScheduledClusterScanScanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cisScanConfig":
            suggest = "cis_scan_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterScheduledClusterScanScanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterScheduledClusterScanScanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterScheduledClusterScanScanConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterScheduledClusterScanScanConfigCisScanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "debugMaster":
            suggest = "debug_master"
        elif key == "debugWorker":
            suggest = "debug_worker"
        elif key == "overrideBenchmarkVersion":
            suggest = "override_benchmark_version"
        elif key == "overrideSkips":
            suggest = "override_skips"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterScheduledClusterScanScanConfigCisScanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterScheduledClusterScanScanConfigCisScanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterScheduledClusterScanScanConfigCisScanConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[Sequence[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 Sequence[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[Sequence[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 ClusterScheduledClusterScanScheduleConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronSchedule":
            suggest = "cron_schedule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterScheduledClusterScanScheduleConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterScheduledClusterScanScheduleConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterScheduledClusterScanScheduleConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cron_schedule: str,
                 retention: Optional[int] = None):
        """
        :param str cron_schedule: Crontab schedule. It should contains 5 fields `"<min> <hour> <month_day> <month> <week_day>"` (string)
        :param int 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[int]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")


@pulumi.output_type
class ClusterSyncNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "externalIpAddress":
            suggest = "external_ip_address"
        elif key == "ipAddress":
            suggest = "ip_address"
        elif key == "nodePoolId":
            suggest = "node_pool_id"
        elif key == "nodeTemplateId":
            suggest = "node_template_id"
        elif key == "providerId":
            suggest = "provider_id"
        elif key == "requestedHostname":
            suggest = "requested_hostname"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "systemInfo":
            suggest = "system_info"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterSyncNode. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterSyncNode.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterSyncNode.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, Any]] = None,
                 capacity: Optional[Mapping[str, Any]] = None,
                 cluster_id: Optional[str] = None,
                 external_ip_address: Optional[str] = None,
                 hostname: Optional[str] = None,
                 id: Optional[str] = None,
                 ip_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 name: Optional[str] = None,
                 node_pool_id: Optional[str] = None,
                 node_template_id: Optional[str] = None,
                 provider_id: Optional[str] = None,
                 requested_hostname: Optional[str] = None,
                 roles: Optional[Sequence[str]] = None,
                 ssh_user: Optional[str] = None,
                 system_info: Optional[Mapping[str, Any]] = None):
        """
        :param Mapping[str, Any] annotations: Annotations of the node (map).
        :param Mapping[str, Any] capacity: The total resources of a node (map).
        :param str cluster_id: The Cluster ID of the node (string).
        :param str external_ip_address: The external IP address of the node (string).
        :param str hostname: The hostname of the node (string).
        :param str id: The ID of the node (string)
        :param str ip_address: The private IP address of the node (string).
        :param Mapping[str, Any] labels: Labels of the node (map).
        :param str name: The name of the node (string).
        :param str node_pool_id: The Node Pool ID of the node (string).
        :param str node_template_id: The Node Template ID of the node (string).
        :param str provider_id: The Provider ID of the node (string).
        :param str requested_hostname: The requested hostname (string).
        :param Sequence[str] roles: Roles of the node. `controlplane`, `etcd` and `worker`. (list)
        :param str ssh_user: The user to connect to the node (string).
        :param Mapping[str, Any] system_info: General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if external_ip_address is not None:
            pulumi.set(__self__, "external_ip_address", external_ip_address)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_pool_id is not None:
            pulumi.set(__self__, "node_pool_id", node_pool_id)
        if node_template_id is not None:
            pulumi.set(__self__, "node_template_id", node_template_id)
        if provider_id is not None:
            pulumi.set(__self__, "provider_id", provider_id)
        if requested_hostname is not None:
            pulumi.set(__self__, "requested_hostname", requested_hostname)
        if roles is not None:
            pulumi.set(__self__, "roles", roles)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if system_info is not None:
            pulumi.set(__self__, "system_info", system_info)

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

    @property
    @pulumi.getter
    def capacity(self) -> Optional[Mapping[str, Any]]:
        """
        The total resources of a node (map).
        """
        return pulumi.get(self, "capacity")

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

    @property
    @pulumi.getter(name="externalIpAddress")
    def external_ip_address(self) -> Optional[str]:
        """
        The external IP address of the node (string).
        """
        return pulumi.get(self, "external_ip_address")

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

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

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        """
        The private IP address of the node (string).
        """
        return pulumi.get(self, "ip_address")

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

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

    @property
    @pulumi.getter(name="nodePoolId")
    def node_pool_id(self) -> Optional[str]:
        """
        The Node Pool ID of the node (string).
        """
        return pulumi.get(self, "node_pool_id")

    @property
    @pulumi.getter(name="nodeTemplateId")
    def node_template_id(self) -> Optional[str]:
        """
        The Node Template ID of the node (string).
        """
        return pulumi.get(self, "node_template_id")

    @property
    @pulumi.getter(name="providerId")
    def provider_id(self) -> Optional[str]:
        """
        The Provider ID of the node (string).
        """
        return pulumi.get(self, "provider_id")

    @property
    @pulumi.getter(name="requestedHostname")
    def requested_hostname(self) -> Optional[str]:
        """
        The requested hostname (string).
        """
        return pulumi.get(self, "requested_hostname")

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

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        The user to connect to the node (string).
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="systemInfo")
    def system_info(self) -> Optional[Mapping[str, Any]]:
        """
        General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
        """
        return pulumi.get(self, "system_info")


@pulumi.output_type
class ClusterTemplateMember(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessType":
            suggest = "access_type"
        elif key == "groupPrincipalId":
            suggest = "group_principal_id"
        elif key == "userPrincipalId":
            suggest = "user_principal_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateMember. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateMember.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateMember.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevision(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterConfig":
            suggest = "cluster_config"
        elif key == "clusterTemplateId":
            suggest = "cluster_template_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevision. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevision.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevision.__key_warning(key)
        return super().get(key, default)

    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[Sequence['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 Sequence['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[Sequence['outputs.ClusterTemplateTemplateRevisionQuestion']]:
        """
        Cluster template questions (list)
        """
        return pulumi.get(self, "questions")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rkeConfig":
            suggest = "rke_config"
        elif key == "clusterAuthEndpoint":
            suggest = "cluster_auth_endpoint"
        elif key == "defaultClusterRoleForProjectMembers":
            suggest = "default_cluster_role_for_project_members"
        elif key == "defaultPodSecurityPolicyTemplateId":
            suggest = "default_pod_security_policy_template_id"
        elif key == "desiredAgentImage":
            suggest = "desired_agent_image"
        elif key == "desiredAuthImage":
            suggest = "desired_auth_image"
        elif key == "dockerRootDir":
            suggest = "docker_root_dir"
        elif key == "enableClusterAlerting":
            suggest = "enable_cluster_alerting"
        elif key == "enableClusterMonitoring":
            suggest = "enable_cluster_monitoring"
        elif key == "enableNetworkPolicy":
            suggest = "enable_network_policy"
        elif key == "scheduledClusterScan":
            suggest = "scheduled_cluster_scan"
        elif key == "windowsPreferedCluster":
            suggest = "windows_prefered_cluster"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caCerts":
            suggest = "ca_certs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "addonJobTimeout":
            suggest = "addon_job_timeout"
        elif key == "addonsIncludes":
            suggest = "addons_includes"
        elif key == "bastionHost":
            suggest = "bastion_host"
        elif key == "cloudProvider":
            suggest = "cloud_provider"
        elif key == "enableCriDockerd":
            suggest = "enable_cri_dockerd"
        elif key == "ignoreDockerVersion":
            suggest = "ignore_docker_version"
        elif key == "kubernetesVersion":
            suggest = "kubernetes_version"
        elif key == "prefixPath":
            suggest = "prefix_path"
        elif key == "privateRegistries":
            suggest = "private_registries"
        elif key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshCertPath":
            suggest = "ssh_cert_path"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"
        elif key == "upgradeStrategy":
            suggest = "upgrade_strategy"
        elif key == "winPrefixPath":
            suggest = "win_prefix_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 addon_job_timeout: Optional[int] = None,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[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,
                 enable_cri_dockerd: Optional[bool] = 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[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode']] = None,
                 prefix_path: Optional[str] = None,
                 private_registries: Optional[Sequence['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,
                 win_prefix_path: Optional[str] = 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 enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if win_prefix_path is not None:
            pulumi.set(__self__, "win_prefix_path", win_prefix_path)

    @property
    @pulumi.getter(name="addonJobTimeout")
    def addon_job_timeout(self) -> Optional[int]:
        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[Sequence[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="enableCriDockerd")
    def enable_cri_dockerd(self) -> Optional[bool]:
        return pulumi.get(self, "enable_cri_dockerd")

    @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[Sequence['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[Sequence['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")

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


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

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


@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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshKey":
            suggest = "ssh_key"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsCloudProvider":
            suggest = "aws_cloud_provider"
        elif key == "azureCloudProvider":
            suggest = "azure_cloud_provider"
        elif key == "customCloudProvider":
            suggest = "custom_cloud_provider"
        elif key == "openstackCloudProvider":
            suggest = "openstack_cloud_provider"
        elif key == "vsphereCloudProvider":
            suggest = "vsphere_cloud_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "global":
            suggest = "global_"
        elif key == "serviceOverrides":
            suggest = "service_overrides"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider.__key_warning(key)
        return super().get(key, default)

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableSecurityGroupIngress":
            suggest = "disable_security_group_ingress"
        elif key == "disableStrictZoneCheck":
            suggest = "disable_strict_zone_check"
        elif key == "elbSecurityGroup":
            suggest = "elb_security_group"
        elif key == "kubernetesClusterId":
            suggest = "kubernetes_cluster_id"
        elif key == "kubernetesClusterTag":
            suggest = "kubernetes_cluster_tag"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "routeTableId":
            suggest = "route_table_id"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "signingMethod":
            suggest = "signing_method"
        elif key == "signingName":
            suggest = "signing_name"
        elif key == "signingRegion":
            suggest = "signing_region"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aadClientId":
            suggest = "aad_client_id"
        elif key == "aadClientSecret":
            suggest = "aad_client_secret"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "aadClientCertPassword":
            suggest = "aad_client_cert_password"
        elif key == "aadClientCertPath":
            suggest = "aad_client_cert_path"
        elif key == "cloudProviderBackoff":
            suggest = "cloud_provider_backoff"
        elif key == "cloudProviderBackoffDuration":
            suggest = "cloud_provider_backoff_duration"
        elif key == "cloudProviderBackoffExponent":
            suggest = "cloud_provider_backoff_exponent"
        elif key == "cloudProviderBackoffJitter":
            suggest = "cloud_provider_backoff_jitter"
        elif key == "cloudProviderBackoffRetries":
            suggest = "cloud_provider_backoff_retries"
        elif key == "cloudProviderRateLimit":
            suggest = "cloud_provider_rate_limit"
        elif key == "cloudProviderRateLimitBucket":
            suggest = "cloud_provider_rate_limit_bucket"
        elif key == "cloudProviderRateLimitQps":
            suggest = "cloud_provider_rate_limit_qps"
        elif key == "loadBalancerSku":
            suggest = "load_balancer_sku"
        elif key == "maximumLoadBalancerRuleCount":
            suggest = "maximum_load_balancer_rule_count"
        elif key == "primaryAvailabilitySetName":
            suggest = "primary_availability_set_name"
        elif key == "primaryScaleSetName":
            suggest = "primary_scale_set_name"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "routeTableName":
            suggest = "route_table_name"
        elif key == "securityGroupName":
            suggest = "security_group_name"
        elif key == "subnetName":
            suggest = "subnet_name"
        elif key == "useInstanceMetadata":
            suggest = "use_instance_metadata"
        elif key == "useManagedIdentityExtension":
            suggest = "use_managed_identity_extension"
        elif key == "vmType":
            suggest = "vm_type"
        elif key == "vnetName":
            suggest = "vnet_name"
        elif key == "vnetResourceGroup":
            suggest = "vnet_resource_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider.__key_warning(key)
        return super().get(key, default)

    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[int] = None,
                 cloud_provider_backoff_exponent: Optional[int] = None,
                 cloud_provider_backoff_jitter: Optional[int] = None,
                 cloud_provider_backoff_retries: Optional[int] = None,
                 cloud_provider_rate_limit: Optional[bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[int] = None,
                 cloud_provider_rate_limit_qps: Optional[int] = None,
                 load_balancer_sku: Optional[str] = None,
                 location: Optional[str] = None,
                 maximum_load_balancer_rule_count: Optional[int] = 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[int]:
        return pulumi.get(self, "cloud_provider_backoff_duration")

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

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

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> Optional[int]:
        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[int]:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "global":
            suggest = "global_"
        elif key == "blockStorage":
            suggest = "block_storage"
        elif key == "loadBalancer":
            suggest = "load_balancer"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bsVersion":
            suggest = "bs_version"
        elif key == "ignoreVolumeAz":
            suggest = "ignore_volume_az"
        elif key == "trustDevicePath":
            suggest = "trust_device_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "caFile":
            suggest = "ca_file"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "trustId":
            suggest = "trust_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createMonitor":
            suggest = "create_monitor"
        elif key == "floatingNetworkId":
            suggest = "floating_network_id"
        elif key == "lbMethod":
            suggest = "lb_method"
        elif key == "lbProvider":
            suggest = "lb_provider"
        elif key == "lbVersion":
            suggest = "lb_version"
        elif key == "manageSecurityGroups":
            suggest = "manage_security_groups"
        elif key == "monitorDelay":
            suggest = "monitor_delay"
        elif key == "monitorMaxRetries":
            suggest = "monitor_max_retries"
        elif key == "monitorTimeout":
            suggest = "monitor_timeout"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "useOctavia":
            suggest = "use_octavia"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer.__key_warning(key)
        return super().get(key, default)

    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[int] = 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[int]:
        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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestTimeout":
            suggest = "request_timeout"
        elif key == "searchOrder":
            suggest = "search_order"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata.__key_warning(key)
        return super().get(key, default)

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "routerId":
            suggest = "router_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualCenters":
            suggest = "virtual_centers"
        elif key == "global":
            suggest = "global_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 virtual_centers: Sequence['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) -> Sequence['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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scsiControllerType":
            suggest = "scsi_controller_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "insecureFlag":
            suggest = "insecure_flag"
        elif key == "soapRoundtripCount":
            suggest = "soap_roundtrip_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 datacenters: Optional[str] = None,
                 insecure_flag: Optional[bool] = None,
                 password: Optional[str] = None,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = 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[int]:
        return pulumi.get(self, "soap_roundtrip_count")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "publicNetwork":
            suggest = "public_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "soapRoundtripCount":
            suggest = "soap_roundtrip_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 user: str,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = 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[int]:
        return pulumi.get(self, "soap_roundtrip_count")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultDatastore":
            suggest = "default_datastore"
        elif key == "resourcepoolPath":
            suggest = "resourcepool_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "linearAutoscalerParams":
            suggest = "linear_autoscaler_params"
        elif key == "nodeSelector":
            suggest = "node_selector"
        elif key == "reverseCidrs":
            suggest = "reverse_cidrs"
        elif key == "updateStrategy":
            suggest = "update_strategy"
        elif key == "upstreamNameservers":
            suggest = "upstream_nameservers"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 linear_autoscaler_params: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams'] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 nodelocal: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal'] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 reverse_cidrs: Optional[Sequence[str]] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy'] = None,
                 upstream_nameservers: Optional[Sequence[str]] = None):
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams']:
        return pulumi.get(self, "linear_autoscaler_params")

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

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

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy']:
        return pulumi.get(self, "update_strategy")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "coresPerReplica":
            suggest = "cores_per_replica"
        elif key == "nodesPerReplica":
            suggest = "nodes_per_replica"
        elif key == "preventSinglePointFailure":
            suggest = "prevent_single_point_failure"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams.__key_warning(key)
        return super().get(key, default)

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

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipAddress":
            suggest = "ip_address"
        elif key == "nodeSelector":
            suggest = "node_selector"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal.__key_warning(key)
        return super().get(key, default)

    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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate'] = 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.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate']:
        return pulumi.get(self, "rolling_update")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"
        elif key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = 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[int]:
        return pulumi.get(self, "max_surge")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultBackend":
            suggest = "default_backend"
        elif key == "dnsPolicy":
            suggest = "dns_policy"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "httpPort":
            suggest = "http_port"
        elif key == "httpsPort":
            suggest = "https_port"
        elif key == "networkMode":
            suggest = "network_mode"
        elif key == "nodeSelector":
            suggest = "node_selector"
        elif key == "updateStrategy":
            suggest = "update_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_backend: Optional[bool] = None,
                 dns_policy: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 http_port: Optional[int] = None,
                 https_port: Optional[int] = None,
                 network_mode: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy'] = None):
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if http_port is not None:
            pulumi.set(__self__, "http_port", http_port)
        if https_port is not None:
            pulumi.set(__self__, "https_port", https_port)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

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

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

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

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

    @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 tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration']]:
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate'] = 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.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate']:
        return pulumi.get(self, "rolling_update")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_unavailable: Optional[int] = None):
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nodeSelector":
            suggest = "node_selector"
        elif key == "updateStrategy":
            suggest = "update_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 replicas: Optional[int] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringToleration']] = 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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[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[int]:
        return pulumi.get(self, "replicas")

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

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"
        elif key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = 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[int]:
        return pulumi.get(self, "max_surge")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "calicoNetworkProvider":
            suggest = "calico_network_provider"
        elif key == "canalNetworkProvider":
            suggest = "canal_network_provider"
        elif key == "flannelNetworkProvider":
            suggest = "flannel_network_provider"
        elif key == "weaveNetworkProvider":
            suggest = "weave_network_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork.__key_warning(key)
        return super().get(key, default)

    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[int] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 plugin: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration']] = 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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="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[int]:
        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
    def tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration']]:
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="weaveNetworkProvider")
    def weave_network_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider']:
        return pulumi.get(self, "weave_network_provider")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudProvider":
            suggest = "cloud_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@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")


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

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

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

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

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

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


@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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dockerSocket":
            suggest = "docker_socket"
        elif key == "hostnameOverride":
            suggest = "hostname_override"
        elif key == "internalAddress":
            suggest = "internal_address"
        elif key == "nodeId":
            suggest = "node_id"
        elif key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshKey":
            suggest = "ssh_key"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: str,
                 roles: Sequence[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) -> Sequence[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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ecrCredentialPlugin":
            suggest = "ecr_credential_plugin"
        elif key == "isDefault":
            suggest = "is_default"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 ecr_credential_plugin: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

    @property
    @pulumi.getter(name="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin']:
        return pulumi.get(self, "ecr_credential_plugin")

    @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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsAccessKeyId":
            suggest = "aws_access_key_id"
        elif key == "awsSecretAccessKey":
            suggest = "aws_secret_access_key"
        elif key == "awsSessionToken":
            suggest = "aws_session_token"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kubeApi":
            suggest = "kube_api"
        elif key == "kubeController":
            suggest = "kube_controller"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backupConfig":
            suggest = "backup_config"
        elif key == "caCert":
            suggest = "ca_cert"
        elif key == "externalUrls":
            suggest = "external_urls"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd.__key_warning(key)
        return super().get(key, default)

    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[Sequence[str]] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 image: Optional[str] = None,
                 key: Optional[str] = None,
                 path: Optional[str] = None,
                 retention: Optional[str] = None,
                 snapshot: Optional[bool] = None,
                 uid: Optional[int] = None):
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional['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[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalHours":
            suggest = "interval_hours"
        elif key == "s3BackupConfig":
            suggest = "s3_backup_config"
        elif key == "safeTimestamp":
            suggest = "safe_timestamp"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig.__key_warning(key)
        return super().get(key, default)

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

    @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[int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        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")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "customCa":
            suggest = "custom_ca"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig.__key_warning(key)
        return super().get(key, default)

    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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "admissionConfiguration":
            suggest = "admission_configuration"
        elif key == "alwaysPullImages":
            suggest = "always_pull_images"
        elif key == "auditLog":
            suggest = "audit_log"
        elif key == "eventRateLimit":
            suggest = "event_rate_limit"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "podSecurityPolicy":
            suggest = "pod_security_policy"
        elif key == "secretsEncryptionConfig":
            suggest = "secrets_encryption_config"
        elif key == "serviceClusterIpRange":
            suggest = "service_cluster_ip_range"
        elif key == "serviceNodePortRange":
            suggest = "service_node_port_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi.__key_warning(key)
        return super().get(key, default)

    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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxAge":
            suggest = "max_age"
        elif key == "maxBackup":
            suggest = "max_backup"
        elif key == "maxSize":
            suggest = "max_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 format: Optional[str] = None,
                 max_age: Optional[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = 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[int]:
        return pulumi.get(self, "max_age")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        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")


@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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customConfig":
            suggest = "custom_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterCidr":
            suggest = "cluster_cidr"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "serviceClusterIpRange":
            suggest = "service_cluster_ip_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_cidr: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterDnsServer":
            suggest = "cluster_dns_server"
        elif key == "clusterDomain":
            suggest = "cluster_domain"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "failSwapOn":
            suggest = "fail_swap_on"
        elif key == "generateServingCertificate":
            suggest = "generate_serving_certificate"
        elif key == "infraContainerImage":
            suggest = "infra_container_image"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_dns_server: Optional[str] = None,
                 cluster_domain: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "drainInput":
            suggest = "drain_input"
        elif key == "maxUnavailableControlplane":
            suggest = "max_unavailable_controlplane"
        elif key == "maxUnavailableWorker":
            suggest = "max_unavailable_worker"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteLocalData":
            suggest = "delete_local_data"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "ignoreDaemonSets":
            suggest = "ignore_daemon_sets"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[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[int]:
        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[int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scanConfig":
            suggest = "scan_config"
        elif key == "scheduleConfig":
            suggest = "schedule_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScan.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cisScanConfig":
            suggest = "cis_scan_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "debugMaster":
            suggest = "debug_master"
        elif key == "debugWorker":
            suggest = "debug_worker"
        elif key == "overrideBenchmarkVersion":
            suggest = "override_benchmark_version"
        elif key == "overrideSkips":
            suggest = "override_skips"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScanConfigCisScanConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 debug_master: Optional[bool] = None,
                 debug_worker: Optional[bool] = None,
                 override_benchmark_version: Optional[str] = None,
                 override_skips: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "override_skips")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronSchedule":
            suggest = "cron_schedule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigScheduledClusterScanScheduleConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cron_schedule: str,
                 retention: Optional[int] = 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[int]:
        return pulumi.get(self, "retention")


@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")


@pulumi.output_type
class ClusterV2AgentEnvVar(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: Name of cluster registration token (string)
        :param str value: The taint value (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class ClusterV2ClusterRegistrationToken(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "insecureCommand":
            suggest = "insecure_command"
        elif key == "insecureNodeCommand":
            suggest = "insecure_node_command"
        elif key == "insecureWindowsNodeCommand":
            suggest = "insecure_windows_node_command"
        elif key == "manifestUrl":
            suggest = "manifest_url"
        elif key == "nodeCommand":
            suggest = "node_command"
        elif key == "windowsNodeCommand":
            suggest = "windows_node_command"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterRegistrationToken. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterRegistrationToken.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterRegistrationToken.__key_warning(key)
        return super().get(key, default)

    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,
                 insecure_node_command: Optional[str] = None,
                 insecure_windows_node_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 str insecure_node_command: Insecure node command to execute in a imported k8s cluster (string)
        :param str insecure_windows_node_command: Insecure windows 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 insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if manifest_url is not None:
            pulumi.set(__self__, "manifest_url", manifest_url)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_command is not None:
            pulumi.set(__self__, "node_command", node_command)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if windows_node_command is not None:
            pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[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(name="insecureNodeCommand")
    def insecure_node_command(self) -> Optional[str]:
        """
        Insecure node command to execute in a imported k8s cluster (string)
        """
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> Optional[str]:
        """
        Insecure windows command to execute in a imported k8s cluster (string)
        """
        return pulumi.get(self, "insecure_windows_node_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")


@pulumi.output_type
class ClusterV2LocalAuthEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caCerts":
            suggest = "ca_certs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2LocalAuthEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2LocalAuthEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2LocalAuthEndpoint.__key_warning(key)
        return super().get(key, default)

    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: Drain options enabled? Default `true` (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]:
        """
        Drain options enabled? Default `true` (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")


@pulumi.output_type
class ClusterV2RkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "additionalManifest":
            suggest = "additional_manifest"
        elif key == "chartValues":
            suggest = "chart_values"
        elif key == "localAuthEndpoint":
            suggest = "local_auth_endpoint"
        elif key == "machineGlobalConfig":
            suggest = "machine_global_config"
        elif key == "machinePools":
            suggest = "machine_pools"
        elif key == "machineSelectorConfigs":
            suggest = "machine_selector_configs"
        elif key == "upgradeStrategy":
            suggest = "upgrade_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 additional_manifest: Optional[str] = None,
                 chart_values: Optional[str] = None,
                 etcd: Optional['outputs.ClusterV2RkeConfigEtcd'] = None,
                 local_auth_endpoint: Optional['outputs.ClusterV2RkeConfigLocalAuthEndpoint'] = None,
                 machine_global_config: Optional[str] = None,
                 machine_pools: Optional[Sequence['outputs.ClusterV2RkeConfigMachinePool']] = None,
                 machine_selector_configs: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorConfig']] = None,
                 registries: Optional['outputs.ClusterV2RkeConfigRegistries'] = None,
                 upgrade_strategy: Optional['outputs.ClusterV2RkeConfigUpgradeStrategy'] = None):
        """
        :param str additional_manifest: Cluster V2 additional manifest (string)
        :param str chart_values: Cluster V2 chart values. Must be in YAML format (string)
        :param 'ClusterV2RkeConfigEtcdArgs' etcd: Cluster V2 etcd (list maxitems:1)
        :param 'ClusterV2RkeConfigLocalAuthEndpointArgs' local_auth_endpoint: Use rancher2_cluster_v2.local_auth_endpoint instead
        :param str machine_global_config: Cluster V2 machine global config. Must be in YAML format (string)
        :param Sequence['ClusterV2RkeConfigMachinePoolArgs'] machine_pools: Cluster V2 machine pools (list)
        :param Sequence['ClusterV2RkeConfigMachineSelectorConfigArgs'] machine_selector_configs: Cluster V2 machine selector config (list)
        :param 'ClusterV2RkeConfigRegistriesArgs' registries: Cluster V2 docker registries (list maxitems:1)
        :param 'ClusterV2RkeConfigUpgradeStrategyArgs' upgrade_strategy: Cluster V2 upgrade strategy (list maxitems:1)
        """
        if additional_manifest is not None:
            pulumi.set(__self__, "additional_manifest", additional_manifest)
        if chart_values is not None:
            pulumi.set(__self__, "chart_values", chart_values)
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if local_auth_endpoint is not None:
            pulumi.set(__self__, "local_auth_endpoint", local_auth_endpoint)
        if machine_global_config is not None:
            pulumi.set(__self__, "machine_global_config", machine_global_config)
        if machine_pools is not None:
            pulumi.set(__self__, "machine_pools", machine_pools)
        if machine_selector_configs is not None:
            pulumi.set(__self__, "machine_selector_configs", machine_selector_configs)
        if registries is not None:
            pulumi.set(__self__, "registries", registries)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter(name="additionalManifest")
    def additional_manifest(self) -> Optional[str]:
        """
        Cluster V2 additional manifest (string)
        """
        return pulumi.get(self, "additional_manifest")

    @property
    @pulumi.getter(name="chartValues")
    def chart_values(self) -> Optional[str]:
        """
        Cluster V2 chart values. Must be in YAML format (string)
        """
        return pulumi.get(self, "chart_values")

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

    @property
    @pulumi.getter(name="localAuthEndpoint")
    def local_auth_endpoint(self) -> Optional['outputs.ClusterV2RkeConfigLocalAuthEndpoint']:
        """
        Use rancher2_cluster_v2.local_auth_endpoint instead
        """
        return pulumi.get(self, "local_auth_endpoint")

    @property
    @pulumi.getter(name="machineGlobalConfig")
    def machine_global_config(self) -> Optional[str]:
        """
        Cluster V2 machine global config. Must be in YAML format (string)
        """
        return pulumi.get(self, "machine_global_config")

    @property
    @pulumi.getter(name="machinePools")
    def machine_pools(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachinePool']]:
        """
        Cluster V2 machine pools (list)
        """
        return pulumi.get(self, "machine_pools")

    @property
    @pulumi.getter(name="machineSelectorConfigs")
    def machine_selector_configs(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorConfig']]:
        """
        Cluster V2 machine selector config (list)
        """
        return pulumi.get(self, "machine_selector_configs")

    @property
    @pulumi.getter
    def registries(self) -> Optional['outputs.ClusterV2RkeConfigRegistries']:
        """
        Cluster V2 docker registries (list maxitems:1)
        """
        return pulumi.get(self, "registries")

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


@pulumi.output_type
class ClusterV2RkeConfigEtcd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableSnapshots":
            suggest = "disable_snapshots"
        elif key == "s3Config":
            suggest = "s3_config"
        elif key == "snapshotRetention":
            suggest = "snapshot_retention"
        elif key == "snapshotScheduleCron":
            suggest = "snapshot_schedule_cron"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigEtcd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigEtcd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigEtcd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disable_snapshots: Optional[bool] = None,
                 s3_config: Optional['outputs.ClusterV2RkeConfigEtcdS3Config'] = None,
                 snapshot_retention: Optional[int] = None,
                 snapshot_schedule_cron: Optional[str] = None):
        """
        :param bool disable_snapshots: Disable ETCD snapshots. Default: `false` (bool)
        :param 'ClusterV2RkeConfigEtcdS3ConfigArgs' s3_config: Creation option for etcd service (list maxitems:1)
        :param int snapshot_retention: ETCD snapshot retention (int)
        :param str snapshot_schedule_cron: ETCD snapshot schedule cron (e.g `\"0 */5 * * *\"`) (string)
        """
        if disable_snapshots is not None:
            pulumi.set(__self__, "disable_snapshots", disable_snapshots)
        if s3_config is not None:
            pulumi.set(__self__, "s3_config", s3_config)
        if snapshot_retention is not None:
            pulumi.set(__self__, "snapshot_retention", snapshot_retention)
        if snapshot_schedule_cron is not None:
            pulumi.set(__self__, "snapshot_schedule_cron", snapshot_schedule_cron)

    @property
    @pulumi.getter(name="disableSnapshots")
    def disable_snapshots(self) -> Optional[bool]:
        """
        Disable ETCD snapshots. Default: `false` (bool)
        """
        return pulumi.get(self, "disable_snapshots")

    @property
    @pulumi.getter(name="s3Config")
    def s3_config(self) -> Optional['outputs.ClusterV2RkeConfigEtcdS3Config']:
        """
        Creation option for etcd service (list maxitems:1)
        """
        return pulumi.get(self, "s3_config")

    @property
    @pulumi.getter(name="snapshotRetention")
    def snapshot_retention(self) -> Optional[int]:
        """
        ETCD snapshot retention (int)
        """
        return pulumi.get(self, "snapshot_retention")

    @property
    @pulumi.getter(name="snapshotScheduleCron")
    def snapshot_schedule_cron(self) -> Optional[str]:
        """
        ETCD snapshot schedule cron (e.g `\"0 */5 * * *\"`) (string)
        """
        return pulumi.get(self, "snapshot_schedule_cron")


@pulumi.output_type
class ClusterV2RkeConfigEtcdS3Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudCredentialName":
            suggest = "cloud_credential_name"
        elif key == "endpointCa":
            suggest = "endpoint_ca"
        elif key == "skipSslVerify":
            suggest = "skip_ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigEtcdS3Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigEtcdS3Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigEtcdS3Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket: str,
                 endpoint: str,
                 cloud_credential_name: Optional[str] = None,
                 endpoint_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 skip_ssl_verify: Optional[bool] = None):
        """
        :param str bucket: Bucket name for S3 service (string)
        :param str endpoint: ETCD snapshot S3 endpoint (string)
        :param str cloud_credential_name: ETCD snapshot S3 cloud credential name (string)
        :param str endpoint_ca: ETCD snapshot S3 endpoint CA (string)
        :param str folder: ETCD snapshot S3 folder (string)
        :param str region: ETCD snapshot S3 region (string)
        :param bool skip_ssl_verify: Disable ETCD skip ssl verify. Default: `false` (bool)
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "endpoint", endpoint)
        if cloud_credential_name is not None:
            pulumi.set(__self__, "cloud_credential_name", cloud_credential_name)
        if endpoint_ca is not None:
            pulumi.set(__self__, "endpoint_ca", endpoint_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if skip_ssl_verify is not None:
            pulumi.set(__self__, "skip_ssl_verify", skip_ssl_verify)

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

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

    @property
    @pulumi.getter(name="cloudCredentialName")
    def cloud_credential_name(self) -> Optional[str]:
        """
        ETCD snapshot S3 cloud credential name (string)
        """
        return pulumi.get(self, "cloud_credential_name")

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[str]:
        """
        ETCD snapshot S3 endpoint CA (string)
        """
        return pulumi.get(self, "endpoint_ca")

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

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

    @property
    @pulumi.getter(name="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[bool]:
        """
        Disable ETCD skip ssl verify. Default: `false` (bool)
        """
        return pulumi.get(self, "skip_ssl_verify")


@pulumi.output_type
class ClusterV2RkeConfigLocalAuthEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caCerts":
            suggest = "ca_certs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigLocalAuthEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigLocalAuthEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigLocalAuthEndpoint.__key_warning(key)
        return super().get(key, default)

    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: Drain options enabled? Default `true` (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]:
        """
        Drain options enabled? Default `true` (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")


@pulumi.output_type
class ClusterV2RkeConfigMachinePool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudCredentialSecretName":
            suggest = "cloud_credential_secret_name"
        elif key == "machineConfig":
            suggest = "machine_config"
        elif key == "controlPlaneRole":
            suggest = "control_plane_role"
        elif key == "etcdRole":
            suggest = "etcd_role"
        elif key == "rollingUpdate":
            suggest = "rolling_update"
        elif key == "workerRole":
            suggest = "worker_role"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachinePool. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachinePool.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachinePool.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_credential_secret_name: str,
                 machine_config: 'outputs.ClusterV2RkeConfigMachinePoolMachineConfig',
                 name: str,
                 annotations: Optional[Mapping[str, Any]] = None,
                 control_plane_role: Optional[bool] = None,
                 etcd_role: Optional[bool] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 paused: Optional[bool] = None,
                 quantity: Optional[int] = None,
                 rolling_update: Optional['outputs.ClusterV2RkeConfigMachinePoolRollingUpdate'] = None,
                 taints: Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolTaint']] = None,
                 worker_role: Optional[bool] = None):
        """
        :param str cloud_credential_secret_name: Cluster V2 cloud credential secret name (string)
        :param 'ClusterV2RkeConfigMachinePoolMachineConfigArgs' machine_config: Machine pool node config (list)
        :param str name: Name of cluster registration token (string)
        :param Mapping[str, Any] annotations: Annotations for cluster registration token object (map)
        :param bool control_plane_role: Machine pool control plane role? (bool)
        :param bool etcd_role: Machine pool etcd role? (bool)
        :param Mapping[str, Any] labels: Labels for cluster registration token object (map)
        :param bool paused: Machine pool paused? (bool)
        :param int quantity: Machine pool quantity (int)
        :param 'ClusterV2RkeConfigMachinePoolRollingUpdateArgs' rolling_update: Machine pool rolling update (List maxitems:1)
        :param Sequence['ClusterV2RkeConfigMachinePoolTaintArgs'] taints: Machine pool taints (list)
        :param bool worker_role: Machine pool worker role? (bool)
        """
        pulumi.set(__self__, "cloud_credential_secret_name", cloud_credential_secret_name)
        pulumi.set(__self__, "machine_config", machine_config)
        pulumi.set(__self__, "name", name)
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if control_plane_role is not None:
            pulumi.set(__self__, "control_plane_role", control_plane_role)
        if etcd_role is not None:
            pulumi.set(__self__, "etcd_role", etcd_role)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if paused is not None:
            pulumi.set(__self__, "paused", paused)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if worker_role is not None:
            pulumi.set(__self__, "worker_role", worker_role)

    @property
    @pulumi.getter(name="cloudCredentialSecretName")
    def cloud_credential_secret_name(self) -> str:
        """
        Cluster V2 cloud credential secret name (string)
        """
        return pulumi.get(self, "cloud_credential_secret_name")

    @property
    @pulumi.getter(name="machineConfig")
    def machine_config(self) -> 'outputs.ClusterV2RkeConfigMachinePoolMachineConfig':
        """
        Machine pool node config (list)
        """
        return pulumi.get(self, "machine_config")

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

    @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="controlPlaneRole")
    def control_plane_role(self) -> Optional[bool]:
        """
        Machine pool control plane role? (bool)
        """
        return pulumi.get(self, "control_plane_role")

    @property
    @pulumi.getter(name="etcdRole")
    def etcd_role(self) -> Optional[bool]:
        """
        Machine pool etcd role? (bool)
        """
        return pulumi.get(self, "etcd_role")

    @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
    def paused(self) -> Optional[bool]:
        """
        Machine pool paused? (bool)
        """
        return pulumi.get(self, "paused")

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

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterV2RkeConfigMachinePoolRollingUpdate']:
        """
        Machine pool rolling update (List maxitems:1)
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolTaint']]:
        """
        Machine pool taints (list)
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="workerRole")
    def worker_role(self) -> Optional[bool]:
        """
        Machine pool worker role? (bool)
        """
        return pulumi.get(self, "worker_role")


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolMachineConfig(dict):
    def __init__(__self__, *,
                 kind: str,
                 name: str):
        """
        :param str kind: Machine config kind (string)
        :param str name: Name of cluster registration token (string)
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxSurge":
            suggest = "max_surge"
        elif key == "maxUnavailable":
            suggest = "max_unavailable"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachinePoolRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachinePoolRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachinePoolRollingUpdate.__key_warning(key)
        return super().get(key, default)

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

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


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolTaint(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 effect: Optional[str] = None):
        """
        :param str key: Machine selector label match expressions key (string)
        :param str value: The taint value (string)
        :param str effect: The taint effect. Default: `\"NoExecute\"` (string)
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Machine selector label match expressions key (string)
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        """
        The taint effect. Default: `\"NoExecute\"` (string)
        """
        return pulumi.get(self, "effect")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "machineLabelSelector":
            suggest = "machine_label_selector"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachineSelectorConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachineSelectorConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachineSelectorConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config: Optional[Mapping[str, Any]] = None,
                 machine_label_selector: Optional['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector'] = None):
        """
        :param Mapping[str, Any] config: Machine selector config (map)
        :param 'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs' machine_label_selector: Machine selector label (list maxitems:1)
        """
        if config is not None:
            pulumi.set(__self__, "config", config)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

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

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector']:
        """
        Machine selector label (list maxitems:1)
        """
        return pulumi.get(self, "machine_label_selector")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "matchExpressions":
            suggest = "match_expressions"
        elif key == "matchLabels":
            suggest = "match_labels"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 match_expressions: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression']] = None,
                 match_labels: Optional[Mapping[str, Any]] = None):
        """
        :param Sequence['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs'] match_expressions: Machine selector label match expressions (list)
        :param Mapping[str, Any] match_labels: Machine selector label match labels (map)
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression']]:
        """
        Machine selector label match expressions (list)
        """
        return pulumi.get(self, "match_expressions")

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[Mapping[str, Any]]:
        """
        Machine selector label match labels (map)
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 operator: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str key: Machine selector label match expressions key (string)
        :param str operator: Machine selector label match expressions operator (string)
        :param Sequence[str] values: Machine selector label match expressions values (List string)
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        Machine selector label match expressions key (string)
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        Machine selector label match expressions operator (string)
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        Machine selector label match expressions values (List string)
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ClusterV2RkeConfigRegistries(dict):
    def __init__(__self__, *,
                 configs: Optional[Sequence['outputs.ClusterV2RkeConfigRegistriesConfig']] = None,
                 mirrors: Optional[Sequence['outputs.ClusterV2RkeConfigRegistriesMirror']] = None):
        """
        :param Sequence['ClusterV2RkeConfigRegistriesConfigArgs'] configs: Cluster V2 docker registries config (list)
        :param Sequence['ClusterV2RkeConfigRegistriesMirrorArgs'] mirrors: Cluster V2 docker registries mirror (list)
        """
        if configs is not None:
            pulumi.set(__self__, "configs", configs)
        if mirrors is not None:
            pulumi.set(__self__, "mirrors", mirrors)

    @property
    @pulumi.getter
    def configs(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigRegistriesConfig']]:
        """
        Cluster V2 docker registries config (list)
        """
        return pulumi.get(self, "configs")

    @property
    @pulumi.getter
    def mirrors(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigRegistriesMirror']]:
        """
        Cluster V2 docker registries mirror (list)
        """
        return pulumi.get(self, "mirrors")


@pulumi.output_type
class ClusterV2RkeConfigRegistriesConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authConfigSecretName":
            suggest = "auth_config_secret_name"
        elif key == "caBundle":
            suggest = "ca_bundle"
        elif key == "tlsSecretName":
            suggest = "tls_secret_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigRegistriesConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigRegistriesConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigRegistriesConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hostname: str,
                 auth_config_secret_name: Optional[str] = None,
                 ca_bundle: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 tls_secret_name: Optional[str] = None):
        """
        :param str hostname: Registry hostname (string)
        :param str auth_config_secret_name: Registry auth config secret name (string)
        :param str ca_bundle: Registry CA bundle (string)
        :param bool insecure: Registry insecure connectivity (bool)
        :param str tls_secret_name: Registry TLS secret name. TLS is a pair of Cert/Key (string)
        """
        pulumi.set(__self__, "hostname", hostname)
        if auth_config_secret_name is not None:
            pulumi.set(__self__, "auth_config_secret_name", auth_config_secret_name)
        if ca_bundle is not None:
            pulumi.set(__self__, "ca_bundle", ca_bundle)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if tls_secret_name is not None:
            pulumi.set(__self__, "tls_secret_name", tls_secret_name)

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

    @property
    @pulumi.getter(name="authConfigSecretName")
    def auth_config_secret_name(self) -> Optional[str]:
        """
        Registry auth config secret name (string)
        """
        return pulumi.get(self, "auth_config_secret_name")

    @property
    @pulumi.getter(name="caBundle")
    def ca_bundle(self) -> Optional[str]:
        """
        Registry CA bundle (string)
        """
        return pulumi.get(self, "ca_bundle")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[bool]:
        """
        Registry insecure connectivity (bool)
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="tlsSecretName")
    def tls_secret_name(self) -> Optional[str]:
        """
        Registry TLS secret name. TLS is a pair of Cert/Key (string)
        """
        return pulumi.get(self, "tls_secret_name")


@pulumi.output_type
class ClusterV2RkeConfigRegistriesMirror(dict):
    def __init__(__self__, *,
                 hostname: str,
                 endpoints: Optional[Sequence[str]] = None,
                 rewrites: Optional[Mapping[str, Any]] = None):
        """
        :param str hostname: Registry hostname (string)
        :param Sequence[str] endpoints: Registry mirror endpoints (List)
        :param Mapping[str, Any] rewrites: Registry mirror rewrites (map)
        """
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

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

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[Sequence[str]]:
        """
        Registry mirror endpoints (List)
        """
        return pulumi.get(self, "endpoints")

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


@pulumi.output_type
class ClusterV2RkeConfigUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "controlPlaneConcurrency":
            suggest = "control_plane_concurrency"
        elif key == "controlPlaneDrainOptions":
            suggest = "control_plane_drain_options"
        elif key == "workerConcurrency":
            suggest = "worker_concurrency"
        elif key == "workerDrainOptions":
            suggest = "worker_drain_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 control_plane_concurrency: Optional[str] = None,
                 control_plane_drain_options: Optional['outputs.ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions'] = None,
                 worker_concurrency: Optional[str] = None,
                 worker_drain_options: Optional['outputs.ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions'] = None):
        """
        :param str control_plane_concurrency: How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted (string)
        :param 'ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs' control_plane_drain_options: Controlplane nodes drain options (list maxitems:1)
        :param str worker_concurrency: How many worker nodes should be upgrade at time. Percentages are also accepted (string)
        :param 'ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs' worker_drain_options: Worker nodes drain options (list maxitems:1)
        """
        if control_plane_concurrency is not None:
            pulumi.set(__self__, "control_plane_concurrency", control_plane_concurrency)
        if control_plane_drain_options is not None:
            pulumi.set(__self__, "control_plane_drain_options", control_plane_drain_options)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)
        if worker_drain_options is not None:
            pulumi.set(__self__, "worker_drain_options", worker_drain_options)

    @property
    @pulumi.getter(name="controlPlaneConcurrency")
    def control_plane_concurrency(self) -> Optional[str]:
        """
        How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted (string)
        """
        return pulumi.get(self, "control_plane_concurrency")

    @property
    @pulumi.getter(name="controlPlaneDrainOptions")
    def control_plane_drain_options(self) -> Optional['outputs.ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions']:
        """
        Controlplane nodes drain options (list maxitems:1)
        """
        return pulumi.get(self, "control_plane_drain_options")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[str]:
        """
        How many worker nodes should be upgrade at time. Percentages are also accepted (string)
        """
        return pulumi.get(self, "worker_concurrency")

    @property
    @pulumi.getter(name="workerDrainOptions")
    def worker_drain_options(self) -> Optional['outputs.ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions']:
        """
        Worker nodes drain options (list maxitems:1)
        """
        return pulumi.get(self, "worker_drain_options")


@pulumi.output_type
class ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteEmptyDirData":
            suggest = "delete_empty_dir_data"
        elif key == "disableEviction":
            suggest = "disable_eviction"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "ignoreDaemonSets":
            suggest = "ignore_daemon_sets"
        elif key == "ignoreErrors":
            suggest = "ignore_errors"
        elif key == "skipWaitForDeleteTimeoutSeconds":
            suggest = "skip_wait_for_delete_timeout_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_empty_dir_data: Optional[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param bool delete_empty_dir_data: Drain options delete empty dir data. Default `false` (bool)
        :param bool disable_eviction: Drain options disable eviction. Default `false` (bool)
        :param bool enabled: Drain options enabled? Default `true` (bool)
        :param bool force: Drain options force. Default `false` (bool)
        :param int grace_period: Drain options grace period (int)
        :param bool ignore_daemon_sets: Drain options ignore daemon sets. Default `true` (bool)
        :param bool ignore_errors: Drain options ignore errors. Default `false` (bool)
        :param int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds (int)
        :param int timeout: Drain options timeout (int)
        """
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)
        if skip_wait_for_delete_timeout_seconds is not None:
            pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[bool]:
        """
        Drain options delete empty dir data. Default `false` (bool)
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[bool]:
        """
        Drain options disable eviction. Default `false` (bool)
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Drain options enabled? Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        """
        Drain options grace period (int)
        """
        return pulumi.get(self, "grace_period")

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

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[bool]:
        """
        Drain options ignore errors. Default `false` (bool)
        """
        return pulumi.get(self, "ignore_errors")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> Optional[int]:
        """
        Drain options skip wait for delete timeout seconds (int)
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

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


@pulumi.output_type
class ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteEmptyDirData":
            suggest = "delete_empty_dir_data"
        elif key == "disableEviction":
            suggest = "disable_eviction"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "ignoreDaemonSets":
            suggest = "ignore_daemon_sets"
        elif key == "ignoreErrors":
            suggest = "ignore_errors"
        elif key == "skipWaitForDeleteTimeoutSeconds":
            suggest = "skip_wait_for_delete_timeout_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_empty_dir_data: Optional[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param bool delete_empty_dir_data: Drain options delete empty dir data. Default `false` (bool)
        :param bool disable_eviction: Drain options disable eviction. Default `false` (bool)
        :param bool enabled: Drain options enabled? Default `true` (bool)
        :param bool force: Drain options force. Default `false` (bool)
        :param int grace_period: Drain options grace period (int)
        :param bool ignore_daemon_sets: Drain options ignore daemon sets. Default `true` (bool)
        :param bool ignore_errors: Drain options ignore errors. Default `false` (bool)
        :param int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds (int)
        :param int timeout: Drain options timeout (int)
        """
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)
        if skip_wait_for_delete_timeout_seconds is not None:
            pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[bool]:
        """
        Drain options delete empty dir data. Default `false` (bool)
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[bool]:
        """
        Drain options disable eviction. Default `false` (bool)
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Drain options enabled? Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        """
        Drain options grace period (int)
        """
        return pulumi.get(self, "grace_period")

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

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[bool]:
        """
        Drain options ignore errors. Default `false` (bool)
        """
        return pulumi.get(self, "ignore_errors")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> Optional[int]:
        """
        Drain options skip wait for delete timeout seconds (int)
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

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


@pulumi.output_type
class EtcdBackupBackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalHours":
            suggest = "interval_hours"
        elif key == "s3BackupConfig":
            suggest = "s3_backup_config"
        elif key == "safeTimestamp":
            suggest = "safe_timestamp"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EtcdBackupBackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EtcdBackupBackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EtcdBackupBackupConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.EtcdBackupBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None,
                 timeout: Optional[int] = None):
        """
        :param bool enabled: Enable etcd backup (bool)
        :param int interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param int 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)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @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[int]:
        """
        Interval hours for etcd backup. Default `12` (int)
        """
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        """
        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")

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


@pulumi.output_type
class EtcdBackupBackupConfigS3BackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "customCa":
            suggest = "custom_ca"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EtcdBackupBackupConfigS3BackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EtcdBackupBackupConfigS3BackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EtcdBackupBackupConfigS3BackupConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class GlobalDnsProviderAlidnsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalDnsProviderAlidnsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalDnsProviderAlidnsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalDnsProviderAlidnsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str):
        """
        :param str access_key: The AWS Access key (string)
        :param str secret_key: The 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:
        """
        The AWS Access key (string)
        """
        return pulumi.get(self, "access_key")

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


@pulumi.output_type
class GlobalDnsProviderCloudflareConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiEmail":
            suggest = "api_email"
        elif key == "apiKey":
            suggest = "api_key"
        elif key == "proxySetting":
            suggest = "proxy_setting"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalDnsProviderCloudflareConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalDnsProviderCloudflareConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalDnsProviderCloudflareConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_email: str,
                 api_key: str,
                 proxy_setting: Optional[bool] = None):
        """
        :param str api_email: The CloudFlare API Email (string)
        :param str api_key: The CloudFlare API Key (string)
        :param bool proxy_setting: CloudFlare Proxy Setting. Default: `false` (bool)
        """
        pulumi.set(__self__, "api_email", api_email)
        pulumi.set(__self__, "api_key", api_key)
        if proxy_setting is not None:
            pulumi.set(__self__, "proxy_setting", proxy_setting)

    @property
    @pulumi.getter(name="apiEmail")
    def api_email(self) -> str:
        """
        The CloudFlare API Email (string)
        """
        return pulumi.get(self, "api_email")

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> str:
        """
        The CloudFlare API Key (string)
        """
        return pulumi.get(self, "api_key")

    @property
    @pulumi.getter(name="proxySetting")
    def proxy_setting(self) -> Optional[bool]:
        """
        CloudFlare Proxy Setting. Default: `false` (bool)
        """
        return pulumi.get(self, "proxy_setting")


@pulumi.output_type
class GlobalDnsProviderRoute53Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "credentialsPath":
            suggest = "credentials_path"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "zoneType":
            suggest = "zone_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalDnsProviderRoute53Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalDnsProviderRoute53Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalDnsProviderRoute53Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 credentials_path: Optional[str] = None,
                 region: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 zone_type: Optional[str] = None):
        """
        :param str access_key: The AWS Access key (string)
        :param str secret_key: The AWS Secret key (string)
        :param str credentials_path: The AWS credentials path. Default: `"/.aws"` (string)
        :param str region: The AWS Region. Default: `"us-west-2"` (string)
        :param str role_arn: The AWS Role ARN (string)
        :param str zone_type: The Route53 zone type `public, private`. Default: `"public"` (string)
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if credentials_path is not None:
            pulumi.set(__self__, "credentials_path", credentials_path)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if zone_type is not None:
            pulumi.set(__self__, "zone_type", zone_type)

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

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

    @property
    @pulumi.getter(name="credentialsPath")
    def credentials_path(self) -> Optional[str]:
        """
        The AWS credentials path. Default: `"/.aws"` (string)
        """
        return pulumi.get(self, "credentials_path")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The AWS Region. Default: `"us-west-2"` (string)
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="zoneType")
    def zone_type(self) -> Optional[str]:
        """
        The Route53 zone type `public, private`. Default: `"public"` (string)
        """
        return pulumi.get(self, "zone_type")


@pulumi.output_type
class GlobalRoleRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroups":
            suggest = "api_groups"
        elif key == "nonResourceUrls":
            suggest = "non_resource_urls"
        elif key == "resourceNames":
            suggest = "resource_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalRoleRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalRoleRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalRoleRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] api_groups: Policy rule api groups (list)
        :param Sequence[str] non_resource_urls: Policy rule non resource urls (list)
        :param Sequence[str] resource_names: Policy rule resource names (list)
        :param Sequence[str] resources: Policy rule resources (list)
        :param Sequence[str] verbs: Policy rule verbs. `bind`, `create`, `delete`, `deletecollection`, `escalate`, `get`, `impersonate`, `list`, `patch`, `update`, `use`, `view`, `watch`, `own` 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[Sequence[str]]:
        """
        Policy rule api groups (list)
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[str]]:
        """
        Policy rule non resource urls (list)
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[str]]:
        """
        Policy rule resource names (list)
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[str]]:
        """
        Policy rule resources (list)
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[str]]:
        """
        Policy rule verbs. `bind`, `create`, `delete`, `deletecollection`, `escalate`, `get`, `impersonate`, `list`, `patch`, `update`, `use`, `view`, `watch`, `own` and `*` values are supported (list)
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class MachineConfigV2Amazonec2Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroups":
            suggest = "security_groups"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "vpcId":
            suggest = "vpc_id"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "blockDurationMinutes":
            suggest = "block_duration_minutes"
        elif key == "deviceName":
            suggest = "device_name"
        elif key == "encryptEbsVolume":
            suggest = "encrypt_ebs_volume"
        elif key == "httpEndpoint":
            suggest = "http_endpoint"
        elif key == "httpTokens":
            suggest = "http_tokens"
        elif key == "iamInstanceProfile":
            suggest = "iam_instance_profile"
        elif key == "insecureTransport":
            suggest = "insecure_transport"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "keypairName":
            suggest = "keypair_name"
        elif key == "kmsKey":
            suggest = "kms_key"
        elif key == "openPorts":
            suggest = "open_ports"
        elif key == "privateAddressOnly":
            suggest = "private_address_only"
        elif key == "requestSpotInstance":
            suggest = "request_spot_instance"
        elif key == "rootSize":
            suggest = "root_size"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "securityGroupReadonly":
            suggest = "security_group_readonly"
        elif key == "sessionToken":
            suggest = "session_token"
        elif key == "spotPrice":
            suggest = "spot_price"
        elif key == "sshKeyContents":
            suggest = "ssh_key_contents"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "useEbsOptimizedInstance":
            suggest = "use_ebs_optimized_instance"
        elif key == "usePrivateAddress":
            suggest = "use_private_address"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2Amazonec2Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2Amazonec2Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2Amazonec2Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ami: str,
                 region: str,
                 security_groups: Sequence[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,
                 http_endpoint: Optional[str] = None,
                 http_tokens: 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[Sequence[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_key_contents: 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 Sequence[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 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 http_endpoint: Enables or disables the HTTP metadata endpoint on your instances (string)
        :param str http_tokens: The state of token usage for your instance metadata requests (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 Sequence[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 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_key_contents: SSH private key contents (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. (string)
        :param str tags: vSphere tags id e.g. `urn:xxx` (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: OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (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 http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if http_tokens is not None:
            pulumi.set(__self__, "http_tokens", http_tokens)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if insecure_transport is not None:
            pulumi.set(__self__, "insecure_transport", insecure_transport)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if 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_key_contents is not None:
            pulumi.set(__self__, "ssh_key_contents", ssh_key_contents)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if use_ebs_optimized_instance is not None:
            pulumi.set(__self__, "use_ebs_optimized_instance", use_ebs_optimized_instance)
        if use_private_address is not None:
            pulumi.set(__self__, "use_private_address", use_private_address)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def ami(self) -> 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) -> Sequence[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]:
        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="httpEndpoint")
    def http_endpoint(self) -> Optional[str]:
        """
        Enables or disables the HTTP metadata endpoint on your instances (string)
        """
        return pulumi.get(self, "http_endpoint")

    @property
    @pulumi.getter(name="httpTokens")
    def http_tokens(self) -> Optional[str]:
        """
        The state of token usage for your instance metadata requests (string)
        """
        return pulumi.get(self, "http_tokens")

    @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[Sequence[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]:
        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="sshKeyContents")
    def ssh_key_contents(self) -> Optional[str]:
        """
        SSH private key contents (string)
        """
        return pulumi.get(self, "ssh_key_contents")

    @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`. (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        vSphere tags id e.g. `urn:xxx` (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]:
        """
        OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (string)
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class MachineConfigV2AzureConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilitySet":
            suggest = "availability_set"
        elif key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "customData":
            suggest = "custom_data"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "dockerPort":
            suggest = "docker_port"
        elif key == "faultDomainCount":
            suggest = "fault_domain_count"
        elif key == "managedDisks":
            suggest = "managed_disks"
        elif key == "noPublicIp":
            suggest = "no_public_ip"
        elif key == "openPorts":
            suggest = "open_ports"
        elif key == "privateIpAddress":
            suggest = "private_ip_address"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "staticPublicIp":
            suggest = "static_public_ip"
        elif key == "storageType":
            suggest = "storage_type"
        elif key == "subnetPrefix":
            suggest = "subnet_prefix"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "updateDomainCount":
            suggest = "update_domain_count"
        elif key == "usePrivateIp":
            suggest = "use_private_ip"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2AzureConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2AzureConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2AzureConfig.__key_warning(key)
        return super().get(key, default)

    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[Sequence[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,
                 tenant_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 Sequence[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`. (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 (string)
        :param str tenant_id: OpenStack tenant id. Conflicts with `tenant_name` (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 tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if update_domain_count is not None:
            pulumi.set(__self__, "update_domain_count", update_domain_count)
        if use_private_ip is not None:
            pulumi.set(__self__, "use_private_ip", use_private_ip)
        if 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[Sequence[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`. (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 (string)
        """
        return pulumi.get(self, "subscription_id")

    @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="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")


@pulumi.output_type
class MachineConfigV2DigitaloceanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessToken":
            suggest = "access_token"
        elif key == "privateNetworking":
            suggest = "private_networking"
        elif key == "sshKeyContents":
            suggest = "ssh_key_contents"
        elif key == "sshKeyFingerprint":
            suggest = "ssh_key_fingerprint"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2DigitaloceanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2DigitaloceanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2DigitaloceanConfig.__key_warning(key)
        return super().get(key, default)

    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_contents: Optional[str] = None,
                 ssh_key_fingerprint: 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_contents: SSH private key contents (string)
        :param str ssh_key_fingerprint: SSH key fingerprint (string)
        :param str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22` (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. (string)
        :param str tags: vSphere tags id e.g. `urn:xxx` (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_contents is not None:
            pulumi.set(__self__, "ssh_key_contents", ssh_key_contents)
        if ssh_key_fingerprint is not None:
            pulumi.set(__self__, "ssh_key_fingerprint", ssh_key_fingerprint)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[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="sshKeyContents")
    def ssh_key_contents(self) -> Optional[str]:
        """
        SSH private key contents (string)
        """
        return pulumi.get(self, "ssh_key_contents")

    @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="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port. Default `22` (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`. (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        vSphere tags id e.g. `urn:xxx` (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")


@pulumi.output_type
class MachineConfigV2LinodeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorizedUsers":
            suggest = "authorized_users"
        elif key == "createPrivateIp":
            suggest = "create_private_ip"
        elif key == "dockerPort":
            suggest = "docker_port"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "rootPass":
            suggest = "root_pass"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "stackscriptData":
            suggest = "stackscript_data"
        elif key == "swapSize":
            suggest = "swap_size"
        elif key == "uaPrefix":
            suggest = "ua_prefix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2LinodeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2LinodeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2LinodeConfig.__key_warning(key)
        return super().get(key, default)

    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` (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. (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` (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` (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`. (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` (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")


@pulumi.output_type
class MachineConfigV2OpenstackConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "activeTimeout":
            suggest = "active_timeout"
        elif key == "applicationCredentialId":
            suggest = "application_credential_id"
        elif key == "applicationCredentialName":
            suggest = "application_credential_name"
        elif key == "applicationCredentialSecret":
            suggest = "application_credential_secret"
        elif key == "bootFromVolume":
            suggest = "boot_from_volume"
        elif key == "configDrive":
            suggest = "config_drive"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "endpointType":
            suggest = "endpoint_type"
        elif key == "flavorId":
            suggest = "flavor_id"
        elif key == "flavorName":
            suggest = "flavor_name"
        elif key == "floatingIpPool":
            suggest = "floating_ip_pool"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "ipVersion":
            suggest = "ip_version"
        elif key == "keypairName":
            suggest = "keypair_name"
        elif key == "netId":
            suggest = "net_id"
        elif key == "netName":
            suggest = "net_name"
        elif key == "novaNetwork":
            suggest = "nova_network"
        elif key == "privateKeyFile":
            suggest = "private_key_file"
        elif key == "secGroups":
            suggest = "sec_groups"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "tenantDomainId":
            suggest = "tenant_domain_id"
        elif key == "tenantDomainName":
            suggest = "tenant_domain_name"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "userDataFile":
            suggest = "user_data_file"
        elif key == "userDomainId":
            suggest = "user_domain_id"
        elif key == "userDomainName":
            suggest = "user_domain_name"
        elif key == "volumeDevicePath":
            suggest = "volume_device_path"
        elif key == "volumeId":
            suggest = "volume_id"
        elif key == "volumeName":
            suggest = "volume_name"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2OpenstackConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2OpenstackConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2OpenstackConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auth_url: str,
                 availability_zone: str,
                 region: str,
                 active_timeout: Optional[str] = None,
                 application_credential_id: Optional[str] = None,
                 application_credential_name: Optional[str] = None,
                 application_credential_secret: Optional[str] = None,
                 boot_from_volume: Optional[bool] = 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_domain_id: Optional[str] = None,
                 tenant_domain_name: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 user_data_file: Optional[str] = None,
                 user_domain_id: Optional[str] = None,
                 user_domain_name: Optional[str] = None,
                 username: Optional[str] = None,
                 volume_device_path: Optional[str] = None,
                 volume_id: Optional[str] = None,
                 volume_name: Optional[str] = None,
                 volume_size: Optional[str] = None,
                 volume_type: 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 active_timeout: OpenStack active timeout Default `200` (string)
        :param str application_credential_id: OpenStack application credential id. Conflicts with `application_credential_name` (string)
        :param str application_credential_name: OpenStack application credential name. Conflicts with `application_credential_id` (string)
        :param str application_credential_secret: OpenStack application credential secret (string)
        :param bool boot_from_volume: Enable booting from volume. Default is `false` (bool)
        :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: OpenStack 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` (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. (string)
        :param str tenant_domain_id: OpenStack tenant domain id. Conflicts with `tenant_domain_name` (string)
        :param str tenant_domain_name: OpenStack tenant domain name. Conflicts with `tenant_domain_id` (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)
        :param str user_domain_id: OpenStack user domain id. Conflicts with `user_domain_name` (string)
        :param str user_domain_name: OpenStack user domain name. Conflicts with `user_domain_id` (string)
        :param str username: OpenStack username (string)
        :param str volume_device_path: OpenStack volume device path (attaching). Applicable only when `boot_from_volume` is `true`. Omit for auto `/dev/vdb`. (string)
               > **Note**: `Required+` denotes that either the _name or _id is required but you cannot use both.
               > **Note**: `Required++` denotes that either the _name or _id is required unless `application_credential_id` is defined.
        :param str volume_id: OpenStack volume id of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param str volume_name: OpenStack volume name of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param str volume_size: OpenStack volume size (GiB). Required when `boot_from_volume` is `true` (string)
        :param str volume_type: OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (string)
        """
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if application_credential_id is not None:
            pulumi.set(__self__, "application_credential_id", application_credential_id)
        if application_credential_name is not None:
            pulumi.set(__self__, "application_credential_name", application_credential_name)
        if application_credential_secret is not None:
            pulumi.set(__self__, "application_credential_secret", application_credential_secret)
        if boot_from_volume is not None:
            pulumi.set(__self__, "boot_from_volume", boot_from_volume)
        if cacert is not None:
            pulumi.set(__self__, "cacert", cacert)
        if config_drive is not None:
            pulumi.set(__self__, "config_drive", config_drive)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if flavor_id is not None:
            pulumi.set(__self__, "flavor_id", flavor_id)
        if flavor_name is not None:
            pulumi.set(__self__, "flavor_name", flavor_name)
        if floating_ip_pool is not None:
            pulumi.set(__self__, "floating_ip_pool", floating_ip_pool)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if ip_version is not None:
            pulumi.set(__self__, "ip_version", ip_version)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if net_id is not None:
            pulumi.set(__self__, "net_id", net_id)
        if net_name is not None:
            pulumi.set(__self__, "net_name", net_name)
        if nova_network is not None:
            pulumi.set(__self__, "nova_network", nova_network)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key_file is not None:
            pulumi.set(__self__, "private_key_file", private_key_file)
        if sec_groups is not None:
            pulumi.set(__self__, "sec_groups", sec_groups)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tenant_domain_id is not None:
            pulumi.set(__self__, "tenant_domain_id", tenant_domain_id)
        if tenant_domain_name is not None:
            pulumi.set(__self__, "tenant_domain_name", tenant_domain_name)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if user_data_file is not None:
            pulumi.set(__self__, "user_data_file", user_data_file)
        if user_domain_id is not None:
            pulumi.set(__self__, "user_domain_id", user_domain_id)
        if user_domain_name is not None:
            pulumi.set(__self__, "user_domain_name", user_domain_name)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if volume_device_path is not None:
            pulumi.set(__self__, "volume_device_path", volume_device_path)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_name is not None:
            pulumi.set(__self__, "volume_name", volume_name)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> 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(name="activeTimeout")
    def active_timeout(self) -> Optional[str]:
        """
        OpenStack active timeout Default `200` (string)
        """
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[str]:
        """
        OpenStack application credential id. Conflicts with `application_credential_name` (string)
        """
        return pulumi.get(self, "application_credential_id")

    @property
    @pulumi.getter(name="applicationCredentialName")
    def application_credential_name(self) -> Optional[str]:
        """
        OpenStack application credential name. Conflicts with `application_credential_id` (string)
        """
        return pulumi.get(self, "application_credential_name")

    @property
    @pulumi.getter(name="applicationCredentialSecret")
    def application_credential_secret(self) -> Optional[str]:
        """
        OpenStack application credential secret (string)
        """
        return pulumi.get(self, "application_credential_secret")

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[bool]:
        """
        Enable booting from volume. Default is `false` (bool)
        """
        return pulumi.get(self, "boot_from_volume")

    @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]:
        """
        OpenStack 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` (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`. (string)
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="tenantDomainId")
    def tenant_domain_id(self) -> Optional[str]:
        """
        OpenStack tenant domain id. Conflicts with `tenant_domain_name` (string)
        """
        return pulumi.get(self, "tenant_domain_id")

    @property
    @pulumi.getter(name="tenantDomainName")
    def tenant_domain_name(self) -> Optional[str]:
        """
        OpenStack tenant domain name. Conflicts with `tenant_domain_id` (string)
        """
        return pulumi.get(self, "tenant_domain_name")

    @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")

    @property
    @pulumi.getter(name="userDomainId")
    def user_domain_id(self) -> Optional[str]:
        """
        OpenStack user domain id. Conflicts with `user_domain_name` (string)
        """
        return pulumi.get(self, "user_domain_id")

    @property
    @pulumi.getter(name="userDomainName")
    def user_domain_name(self) -> Optional[str]:
        """
        OpenStack user domain name. Conflicts with `user_domain_id` (string)
        """
        return pulumi.get(self, "user_domain_name")

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

    @property
    @pulumi.getter(name="volumeDevicePath")
    def volume_device_path(self) -> Optional[str]:
        """
        OpenStack volume device path (attaching). Applicable only when `boot_from_volume` is `true`. Omit for auto `/dev/vdb`. (string)
        > **Note**: `Required+` denotes that either the _name or _id is required but you cannot use both.
        > **Note**: `Required++` denotes that either the _name or _id is required unless `application_credential_id` is defined.
        """
        return pulumi.get(self, "volume_device_path")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[str]:
        """
        OpenStack volume id of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        """
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter(name="volumeName")
    def volume_name(self) -> Optional[str]:
        """
        OpenStack volume name of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        """
        return pulumi.get(self, "volume_name")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[str]:
        """
        OpenStack volume size (GiB). Required when `boot_from_volume` is `true` (string)
        """
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        """
        OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (string)
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class MachineConfigV2VsphereConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "boot2dockerUrl":
            suggest = "boot2docker_url"
        elif key == "cloneFrom":
            suggest = "clone_from"
        elif key == "cloudConfig":
            suggest = "cloud_config"
        elif key == "contentLibrary":
            suggest = "content_library"
        elif key == "cpuCount":
            suggest = "cpu_count"
        elif key == "creationType":
            suggest = "creation_type"
        elif key == "customAttributes":
            suggest = "custom_attributes"
        elif key == "datastoreCluster":
            suggest = "datastore_cluster"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "memorySize":
            suggest = "memory_size"
        elif key == "sshPassword":
            suggest = "ssh_password"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "sshUserGroup":
            suggest = "ssh_user_group"
        elif key == "vappIpAllocationPolicy":
            suggest = "vapp_ip_allocation_policy"
        elif key == "vappIpProtocol":
            suggest = "vapp_ip_protocol"
        elif key == "vappProperties":
            suggest = "vapp_properties"
        elif key == "vappTransport":
            suggest = "vapp_transport"
        elif key == "vcenterPort":
            suggest = "vcenter_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2VsphereConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2VsphereConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2VsphereConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boot2docker_url: Optional[str] = None,
                 cfgparams: Optional[Sequence[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[Sequence[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[Sequence[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[Sequence[str]] = None,
                 username: Optional[str] = None,
                 vapp_ip_allocation_policy: Optional[str] = None,
                 vapp_ip_protocol: Optional[str] = None,
                 vapp_properties: Optional[Sequence[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 Sequence[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 (string)
        :param str cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data (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 (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` (string)
        :param Sequence[str] custom_attributes: vSphere custom attributes, format key/value e.g. `200=my custom value` (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 (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 Sequence[str] networks: vSphere network where the docker VM will be attached (list)
        :param str password: OpenStack 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` (string)
        :param str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22` (string)
        :param str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. (string)
        :param str ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed. Default `staff` (string)
        :param Sequence[str] tags: vSphere tags id e.g. `urn:xxx` (list)
        :param str username: OpenStack username (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 Sequence[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 (string)
        :param str vcenter_port: vSphere Port for vCenter 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[Sequence[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 (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 (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 (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` (string)
        """
        return pulumi.get(self, "creation_type")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[Sequence[str]]:
        """
        vSphere custom attributes, format key/value e.g. `200=my custom value` (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 (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[Sequence[str]]:
        """
        vSphere network where the docker VM will be attached (list)
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        OpenStack 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` (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` (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`. (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` (string)
        """
        return pulumi.get(self, "ssh_user_group")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        vSphere tags id e.g. `urn:xxx` (list)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        OpenStack username (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[Sequence[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 (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")


@pulumi.output_type
class MultiClusterAppAnswer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "projectId":
            suggest = "project_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppAnswer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppAnswer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppAnswer.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class MultiClusterAppMember(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessType":
            suggest = "access_type"
        elif key == "groupPrincipalId":
            suggest = "group_principal_id"
        elif key == "userPrincipalId":
            suggest = "user_principal_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppMember. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppMember.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppMember.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class MultiClusterAppTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectId":
            suggest = "project_id"
        elif key == "appId":
            suggest = "app_id"
        elif key == "healthState":
            suggest = "health_state"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppTarget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppTarget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppTarget.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class MultiClusterAppUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class MultiClusterAppUpgradeStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "batchSize":
            suggest = "batch_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppUpgradeStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppUpgradeStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppUpgradeStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 batch_size: Optional[int] = None,
                 interval: Optional[int] = None):
        """
        :param int batch_size: Rolling update batch size. Default `1` (int)
        :param int 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[int]:
        """
        Rolling update batch size. Default `1` (int)
        """
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        Rolling update interval. Default `1` (int)
        """
        return pulumi.get(self, "interval")


@pulumi.output_type
class NamespaceContainerResourceLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NamespaceContainerResourceLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NamespaceContainerResourceLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NamespaceContainerResourceLimit.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@pulumi.output_type
class NamespaceResourceQuotaLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMaps":
            suggest = "config_maps"
        elif key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "persistentVolumeClaims":
            suggest = "persistent_volume_claims"
        elif key == "replicationControllers":
            suggest = "replication_controllers"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"
        elif key == "requestsStorage":
            suggest = "requests_storage"
        elif key == "servicesLoadBalancers":
            suggest = "services_load_balancers"
        elif key == "servicesNodePorts":
            suggest = "services_node_ports"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NamespaceResourceQuotaLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NamespaceResourceQuotaLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NamespaceResourceQuotaLimit.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NodePoolNodeTaint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeAdded":
            suggest = "time_added"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeTaint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodePoolNodeTaint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodePoolNodeTaint.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NodeTemplateAmazonec2Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroups":
            suggest = "security_groups"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "vpcId":
            suggest = "vpc_id"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "blockDurationMinutes":
            suggest = "block_duration_minutes"
        elif key == "deviceName":
            suggest = "device_name"
        elif key == "encryptEbsVolume":
            suggest = "encrypt_ebs_volume"
        elif key == "iamInstanceProfile":
            suggest = "iam_instance_profile"
        elif key == "insecureTransport":
            suggest = "insecure_transport"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "keypairName":
            suggest = "keypair_name"
        elif key == "kmsKey":
            suggest = "kms_key"
        elif key == "openPorts":
            suggest = "open_ports"
        elif key == "privateAddressOnly":
            suggest = "private_address_only"
        elif key == "requestSpotInstance":
            suggest = "request_spot_instance"
        elif key == "rootSize":
            suggest = "root_size"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "securityGroupReadonly":
            suggest = "security_group_readonly"
        elif key == "sessionToken":
            suggest = "session_token"
        elif key == "spotPrice":
            suggest = "spot_price"
        elif key == "sshKeypath":
            suggest = "ssh_keypath"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "useEbsOptimizedInstance":
            suggest = "use_ebs_optimized_instance"
        elif key == "usePrivateAddress":
            suggest = "use_private_address"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateAmazonec2Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateAmazonec2Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateAmazonec2Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ami: str,
                 region: str,
                 security_groups: Sequence[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[Sequence[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 Sequence[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 Sequence[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: OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (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) -> Sequence[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[Sequence[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]:
        """
        OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (string)
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class NodeTemplateAzureConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilitySet":
            suggest = "availability_set"
        elif key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "customData":
            suggest = "custom_data"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "dockerPort":
            suggest = "docker_port"
        elif key == "faultDomainCount":
            suggest = "fault_domain_count"
        elif key == "managedDisks":
            suggest = "managed_disks"
        elif key == "noPublicIp":
            suggest = "no_public_ip"
        elif key == "openPorts":
            suggest = "open_ports"
        elif key == "privateIpAddress":
            suggest = "private_ip_address"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "staticPublicIp":
            suggest = "static_public_ip"
        elif key == "storageType":
            suggest = "storage_type"
        elif key == "subnetPrefix":
            suggest = "subnet_prefix"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "updateDomainCount":
            suggest = "update_domain_count"
        elif key == "usePrivateIp":
            suggest = "use_private_ip"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateAzureConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateAzureConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateAzureConfig.__key_warning(key)
        return super().get(key, default)

    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[Sequence[str]] = None,
                 plan: Optional[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 Sequence[str] open_ports: Make the specified port number accessible from the Internet. (list)
        :param str plan: Azure marketplace purchase plan for Azure Virtual Machine. Format is `<publisher>:<product>:<plan>`. Just for Rancher v2.6.3 and above. (string)
        :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 plan is not None:
            pulumi.set(__self__, "plan", plan)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if static_public_ip is not None:
            pulumi.set(__self__, "static_public_ip", static_public_ip)
        if storage_type is not None:
            pulumi.set(__self__, "storage_type", storage_type)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if subnet_prefix is not None:
            pulumi.set(__self__, "subnet_prefix", subnet_prefix)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if 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[Sequence[str]]:
        """
        Make the specified port number accessible from the Internet. (list)
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter
    def plan(self) -> Optional[str]:
        """
        Azure marketplace purchase plan for Azure Virtual Machine. Format is `<publisher>:<product>:<plan>`. Just for Rancher v2.6.3 and above. (string)
        """
        return pulumi.get(self, "plan")

    @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")


@pulumi.output_type
class NodeTemplateDigitaloceanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessToken":
            suggest = "access_token"
        elif key == "privateNetworking":
            suggest = "private_networking"
        elif key == "sshKeyFingerprint":
            suggest = "ssh_key_fingerprint"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateDigitaloceanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateDigitaloceanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateDigitaloceanConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NodeTemplateHetznerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiToken":
            suggest = "api_token"
        elif key == "serverLocation":
            suggest = "server_location"
        elif key == "serverType":
            suggest = "server_type"
        elif key == "usePrivateNetwork":
            suggest = "use_private_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateHetznerConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateHetznerConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateHetznerConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_token: str,
                 image: Optional[str] = None,
                 networks: Optional[str] = None,
                 server_location: Optional[str] = None,
                 server_type: Optional[str] = None,
                 use_private_network: Optional[bool] = None,
                 userdata: Optional[str] = None,
                 volumes: Optional[str] = None):
        """
        :param str api_token: Hetzner Cloud project API token (string)
        :param str image: Specifies the Linode Instance image which determines the OS distribution and base files. Default `linode/ubuntu18.04` (string)
        :param str networks: Comma-separated list of network IDs or names which should be attached to the server private network interface (string)
        :param str server_location: Hetzner Cloud datacenter. Default `nbg1` (string)
        :param str server_type: Hetzner Cloud server type. Default `cx11` (string)
        :param bool use_private_network: Use private network. Default `false` (bool)
        :param str userdata: Path to file with cloud-init user-data (string)
        :param str volumes: Comma-separated list of volume IDs or names which should be attached to the server (string)
        """
        pulumi.set(__self__, "api_token", api_token)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if server_location is not None:
            pulumi.set(__self__, "server_location", server_location)
        if server_type is not None:
            pulumi.set(__self__, "server_type", server_type)
        if use_private_network is not None:
            pulumi.set(__self__, "use_private_network", use_private_network)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)

    @property
    @pulumi.getter(name="apiToken")
    def api_token(self) -> str:
        """
        Hetzner Cloud project API token (string)
        """
        return pulumi.get(self, "api_token")

    @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 networks(self) -> Optional[str]:
        """
        Comma-separated list of network IDs or names which should be attached to the server private network interface (string)
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter(name="serverLocation")
    def server_location(self) -> Optional[str]:
        """
        Hetzner Cloud datacenter. Default `nbg1` (string)
        """
        return pulumi.get(self, "server_location")

    @property
    @pulumi.getter(name="serverType")
    def server_type(self) -> Optional[str]:
        """
        Hetzner Cloud server type. Default `cx11` (string)
        """
        return pulumi.get(self, "server_type")

    @property
    @pulumi.getter(name="usePrivateNetwork")
    def use_private_network(self) -> Optional[bool]:
        """
        Use private network. Default `false` (bool)
        """
        return pulumi.get(self, "use_private_network")

    @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
    def volumes(self) -> Optional[str]:
        """
        Comma-separated list of volume IDs or names which should be attached to the server (string)
        """
        return pulumi.get(self, "volumes")


@pulumi.output_type
class NodeTemplateLinodeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorizedUsers":
            suggest = "authorized_users"
        elif key == "createPrivateIp":
            suggest = "create_private_ip"
        elif key == "dockerPort":
            suggest = "docker_port"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "rootPass":
            suggest = "root_pass"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "stackscriptData":
            suggest = "stackscript_data"
        elif key == "swapSize":
            suggest = "swap_size"
        elif key == "uaPrefix":
            suggest = "ua_prefix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateLinodeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateLinodeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateLinodeConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NodeTemplateNodeTaint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeAdded":
            suggest = "time_added"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateNodeTaint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateNodeTaint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateNodeTaint.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NodeTemplateOpennebulaConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "xmlRpcUrl":
            suggest = "xml_rpc_url"
        elif key == "b2dSize":
            suggest = "b2d_size"
        elif key == "devPrefix":
            suggest = "dev_prefix"
        elif key == "disableVnc":
            suggest = "disable_vnc"
        elif key == "diskResize":
            suggest = "disk_resize"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "imageOwner":
            suggest = "image_owner"
        elif key == "networkId":
            suggest = "network_id"
        elif key == "networkName":
            suggest = "network_name"
        elif key == "networkOwner":
            suggest = "network_owner"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "templateId":
            suggest = "template_id"
        elif key == "templateName":
            suggest = "template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateOpennebulaConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateOpennebulaConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateOpennebulaConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NodeTemplateOpenstackConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "activeTimeout":
            suggest = "active_timeout"
        elif key == "applicationCredentialId":
            suggest = "application_credential_id"
        elif key == "applicationCredentialName":
            suggest = "application_credential_name"
        elif key == "applicationCredentialSecret":
            suggest = "application_credential_secret"
        elif key == "bootFromVolume":
            suggest = "boot_from_volume"
        elif key == "configDrive":
            suggest = "config_drive"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "endpointType":
            suggest = "endpoint_type"
        elif key == "flavorId":
            suggest = "flavor_id"
        elif key == "flavorName":
            suggest = "flavor_name"
        elif key == "floatingIpPool":
            suggest = "floating_ip_pool"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "ipVersion":
            suggest = "ip_version"
        elif key == "keypairName":
            suggest = "keypair_name"
        elif key == "netId":
            suggest = "net_id"
        elif key == "netName":
            suggest = "net_name"
        elif key == "novaNetwork":
            suggest = "nova_network"
        elif key == "privateKeyFile":
            suggest = "private_key_file"
        elif key == "secGroups":
            suggest = "sec_groups"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "userDataFile":
            suggest = "user_data_file"
        elif key == "volumeDevicePath":
            suggest = "volume_device_path"
        elif key == "volumeId":
            suggest = "volume_id"
        elif key == "volumeName":
            suggest = "volume_name"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateOpenstackConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateOpenstackConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateOpenstackConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auth_url: str,
                 availability_zone: str,
                 region: str,
                 active_timeout: Optional[str] = None,
                 application_credential_id: Optional[str] = None,
                 application_credential_name: Optional[str] = None,
                 application_credential_secret: Optional[str] = None,
                 boot_from_volume: Optional[bool] = 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,
                 username: Optional[str] = None,
                 volume_device_path: Optional[str] = None,
                 volume_id: Optional[str] = None,
                 volume_name: Optional[str] = None,
                 volume_size: Optional[str] = None,
                 volume_type: 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 active_timeout: OpenStack active timeout Default `200` (string)
        :param str application_credential_id: OpenStack application credential id. Conflicts with `application_credential_name` (string)
        :param str application_credential_name: OpenStack application credential name. Conflicts with `application_credential_id` (string)
        :param str application_credential_secret: OpenStack application credential secret (string)
        :param bool boot_from_volume: Enable booting from volume. Default is `false` (bool)
        :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)
        :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 volume_device_path: OpenStack volume device path (attaching). Applicable only when `boot_from_volume` is `true`. Omit for auto `/dev/vdb`. (string)
        :param str volume_id: OpenStack volume id of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param str volume_name: OpenStack volume name of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param str volume_size: OpenStack volume size (GiB). Required when `boot_from_volume` is `true` (string)
        :param str volume_type: OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (string)
        """
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if application_credential_id is not None:
            pulumi.set(__self__, "application_credential_id", application_credential_id)
        if application_credential_name is not None:
            pulumi.set(__self__, "application_credential_name", application_credential_name)
        if application_credential_secret is not None:
            pulumi.set(__self__, "application_credential_secret", application_credential_secret)
        if boot_from_volume is not None:
            pulumi.set(__self__, "boot_from_volume", boot_from_volume)
        if cacert is not None:
            pulumi.set(__self__, "cacert", cacert)
        if config_drive is not None:
            pulumi.set(__self__, "config_drive", config_drive)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if flavor_id is not None:
            pulumi.set(__self__, "flavor_id", flavor_id)
        if flavor_name is not None:
            pulumi.set(__self__, "flavor_name", flavor_name)
        if floating_ip_pool is not None:
            pulumi.set(__self__, "floating_ip_pool", floating_ip_pool)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if ip_version is not None:
            pulumi.set(__self__, "ip_version", ip_version)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if net_id is not None:
            pulumi.set(__self__, "net_id", net_id)
        if net_name is not None:
            pulumi.set(__self__, "net_name", net_name)
        if nova_network is not None:
            pulumi.set(__self__, "nova_network", nova_network)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key_file is not None:
            pulumi.set(__self__, "private_key_file", private_key_file)
        if sec_groups is not None:
            pulumi.set(__self__, "sec_groups", sec_groups)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if user_data_file is not None:
            pulumi.set(__self__, "user_data_file", user_data_file)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if volume_device_path is not None:
            pulumi.set(__self__, "volume_device_path", volume_device_path)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_name is not None:
            pulumi.set(__self__, "volume_name", volume_name)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> 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(name="activeTimeout")
    def active_timeout(self) -> Optional[str]:
        """
        OpenStack active timeout Default `200` (string)
        """
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[str]:
        """
        OpenStack application credential id. Conflicts with `application_credential_name` (string)
        """
        return pulumi.get(self, "application_credential_id")

    @property
    @pulumi.getter(name="applicationCredentialName")
    def application_credential_name(self) -> Optional[str]:
        """
        OpenStack application credential name. Conflicts with `application_credential_id` (string)
        """
        return pulumi.get(self, "application_credential_name")

    @property
    @pulumi.getter(name="applicationCredentialSecret")
    def application_credential_secret(self) -> Optional[str]:
        """
        OpenStack application credential secret (string)
        """
        return pulumi.get(self, "application_credential_secret")

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[bool]:
        """
        Enable booting from volume. Default is `false` (bool)
        """
        return pulumi.get(self, "boot_from_volume")

    @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")

    @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="volumeDevicePath")
    def volume_device_path(self) -> Optional[str]:
        """
        OpenStack volume device path (attaching). Applicable only when `boot_from_volume` is `true`. Omit for auto `/dev/vdb`. (string)
        """
        return pulumi.get(self, "volume_device_path")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[str]:
        """
        OpenStack volume id of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        """
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter(name="volumeName")
    def volume_name(self) -> Optional[str]:
        """
        OpenStack volume name of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        """
        return pulumi.get(self, "volume_name")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[str]:
        """
        OpenStack volume size (GiB). Required when `boot_from_volume` is `true` (string)
        """
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        """
        OpenStack volume type. Required when `boot_from_volume` is `true` and openstack cloud does not have a default volume type (string)
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class NodeTemplateVsphereConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "boot2dockerUrl":
            suggest = "boot2docker_url"
        elif key == "cloneFrom":
            suggest = "clone_from"
        elif key == "cloudConfig":
            suggest = "cloud_config"
        elif key == "contentLibrary":
            suggest = "content_library"
        elif key == "cpuCount":
            suggest = "cpu_count"
        elif key == "creationType":
            suggest = "creation_type"
        elif key == "customAttributes":
            suggest = "custom_attributes"
        elif key == "datastoreCluster":
            suggest = "datastore_cluster"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "memorySize":
            suggest = "memory_size"
        elif key == "sshPassword":
            suggest = "ssh_password"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "sshUserGroup":
            suggest = "ssh_user_group"
        elif key == "vappIpAllocationPolicy":
            suggest = "vapp_ip_allocation_policy"
        elif key == "vappIpProtocol":
            suggest = "vapp_ip_protocol"
        elif key == "vappProperties":
            suggest = "vapp_properties"
        elif key == "vappTransport":
            suggest = "vapp_transport"
        elif key == "vcenterPort":
            suggest = "vcenter_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateVsphereConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateVsphereConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateVsphereConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boot2docker_url: Optional[str] = None,
                 cfgparams: Optional[Sequence[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[Sequence[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[Sequence[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[Sequence[str]] = None,
                 username: Optional[str] = None,
                 vapp_ip_allocation_policy: Optional[str] = None,
                 vapp_ip_protocol: Optional[str] = None,
                 vapp_properties: Optional[Sequence[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 Sequence[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: Cloud Config YAML content to inject as 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 Sequence[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 Sequence[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 Sequence[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 Sequence[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[Sequence[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]:
        """
        Cloud Config YAML content to inject as 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[Sequence[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[Sequence[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[Sequence[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[Sequence[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")


@pulumi.output_type
class NotifierDingtalkConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierDingtalkConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierDingtalkConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierDingtalkConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None,
                 secret: Optional[str] = None):
        """
        :param str url: Webhook url (string)
        :param str proxy_url: Wechat proxy url (string)
        :param str secret: Wechat agent ID (string)
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook url (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")

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


@pulumi.output_type
class NotifierMsteamsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierMsteamsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierMsteamsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierMsteamsConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NotifierPagerdutyConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serviceKey":
            suggest = "service_key"
        elif key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierPagerdutyConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierPagerdutyConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierPagerdutyConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NotifierSlackConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierSlackConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierSlackConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierSlackConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NotifierSmtpConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRecipient":
            suggest = "default_recipient"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierSmtpConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierSmtpConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierSmtpConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_recipient: str,
                 host: str,
                 port: int,
                 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 int 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) -> int:
        """
        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")


@pulumi.output_type
class NotifierWebhookConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierWebhookConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierWebhookConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierWebhookConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class NotifierWechatConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "proxyUrl":
            suggest = "proxy_url"
        elif key == "recipientType":
            suggest = "recipient_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierWechatConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierWechatConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierWechatConfig.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@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")


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedHostPath(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pathPrefix":
            suggest = "path_prefix"
        elif key == "readOnly":
            suggest = "read_only"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityPolicyTemplateAllowedHostPath. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityPolicyTemplateAllowedHostPath.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityPolicyTemplateAllowedHostPath.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class PodSecurityPolicyTemplateFsGroup(dict):
    def __init__(__self__, *,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateFsGroupRange']] = None,
                 rule: Optional[str] = None):
        """
        :param Sequence['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[Sequence['outputs.PodSecurityPolicyTemplateFsGroupRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

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


@pulumi.output_type
class PodSecurityPolicyTemplateFsGroupRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: (int)
        :param int min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class PodSecurityPolicyTemplateHostPort(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: (int)
        :param int min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsGroup(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateRunAsGroupRange']] = None):
        """
        :param str rule: (string)
        :param Sequence['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[Sequence['outputs.PodSecurityPolicyTemplateRunAsGroupRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsGroupRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: (int)
        :param int min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsUser(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateRunAsUserRange']] = None):
        """
        :param str rule: (string)
        :param Sequence['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[Sequence['outputs.PodSecurityPolicyTemplateRunAsUserRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsUserRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: (int)
        :param int min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class PodSecurityPolicyTemplateRuntimeClass(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedRuntimeClassNames":
            suggest = "allowed_runtime_class_names"
        elif key == "defaultRuntimeClassName":
            suggest = "default_runtime_class_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityPolicyTemplateRuntimeClass. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityPolicyTemplateRuntimeClass.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityPolicyTemplateRuntimeClass.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_runtime_class_names: Sequence[str],
                 default_runtime_class_name: Optional[str] = None):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class PodSecurityPolicyTemplateSeLinux(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seLinuxOption":
            suggest = "se_linux_option"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityPolicyTemplateSeLinux. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityPolicyTemplateSeLinux.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityPolicyTemplateSeLinux.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@pulumi.output_type
class PodSecurityPolicyTemplateSupplementalGroup(dict):
    def __init__(__self__, *,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateSupplementalGroupRange']] = None,
                 rule: Optional[str] = None):
        """
        :param Sequence['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[Sequence['outputs.PodSecurityPolicyTemplateSupplementalGroupRange']]:
        """
        (list)
        """
        return pulumi.get(self, "ranges")

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


@pulumi.output_type
class PodSecurityPolicyTemplateSupplementalGroupRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: (int)
        :param int min: (int)
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class ProjectAlertGroupRecipient(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notifierId":
            suggest = "notifier_id"
        elif key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "notifierType":
            suggest = "notifier_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertGroupRecipient. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertGroupRecipient.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertGroupRecipient.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectAlertRuleMetricRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdValue":
            suggest = "threshold_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertRuleMetricRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertRuleMetricRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertRuleMetricRule.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectAlertRulePodRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podId":
            suggest = "pod_id"
        elif key == "restartIntervalSeconds":
            suggest = "restart_interval_seconds"
        elif key == "restartTimes":
            suggest = "restart_times"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertRulePodRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertRulePodRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertRulePodRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pod_id: str,
                 condition: Optional[str] = None,
                 restart_interval_seconds: Optional[int] = None,
                 restart_times: Optional[int] = None):
        """
        :param str pod_id: Pod ID (string)
        :param str condition: Pod rule condition. Supported values : `"notrunning" | "notscheduled" | "restarts"`. Default: `notrunning` (string)
        :param int restart_interval_seconds: Pod rule restart interval seconds. Default: `300` (int)
        :param int 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[int]:
        """
        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[int]:
        """
        Pod rule restart times. Default: `3`  (int)
        """
        return pulumi.get(self, "restart_times")


@pulumi.output_type
class ProjectAlertRuleWorkloadRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availablePercentage":
            suggest = "available_percentage"
        elif key == "workloadId":
            suggest = "workload_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertRuleWorkloadRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertRuleWorkloadRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertRuleWorkloadRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 available_percentage: Optional[int] = None,
                 selector: Optional[Mapping[str, Any]] = None,
                 workload_id: Optional[str] = None):
        """
        :param int 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[int]:
        """
        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")


@pulumi.output_type
class ProjectContainerResourceLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectContainerResourceLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectContainerResourceLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectContainerResourceLimit.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectLoggingCustomTargetConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingCustomTargetConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingCustomTargetConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingCustomTargetConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectLoggingElasticsearchConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authPassword":
            suggest = "auth_password"
        elif key == "authUsername":
            suggest = "auth_username"
        elif key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "clientKeyPass":
            suggest = "client_key_pass"
        elif key == "dateFormat":
            suggest = "date_format"
        elif key == "indexPrefix":
            suggest = "index_prefix"
        elif key == "sslVerify":
            suggest = "ssl_verify"
        elif key == "sslVersion":
            suggest = "ssl_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingElasticsearchConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingElasticsearchConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingElasticsearchConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectLoggingFluentdConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fluentServers":
            suggest = "fluent_servers"
        elif key == "enableTls":
            suggest = "enable_tls"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingFluentdConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingFluentdConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingFluentdConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fluent_servers: Sequence['outputs.ProjectLoggingFluentdConfigFluentServer'],
                 certificate: Optional[str] = None,
                 compress: Optional[bool] = None,
                 enable_tls: Optional[bool] = None):
        """
        :param Sequence['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) -> Sequence['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")


@pulumi.output_type
class ProjectLoggingFluentdConfigFluentServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sharedKey":
            suggest = "shared_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingFluentdConfigFluentServer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingFluentdConfigFluentServer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingFluentdConfigFluentServer.__key_warning(key)
        return super().get(key, default)

    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[int] = 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 int 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[int]:
        """
        Weight of the fluentd server (int)
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class ProjectLoggingKafkaConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "brokerEndpoints":
            suggest = "broker_endpoints"
        elif key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "zookeeperEndpoint":
            suggest = "zookeeper_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingKafkaConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingKafkaConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingKafkaConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 topic: str,
                 broker_endpoints: Optional[Sequence[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 Sequence[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[Sequence[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")


@pulumi.output_type
class ProjectLoggingSplunkConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "clientKeyPass":
            suggest = "client_key_pass"
        elif key == "sslVerify":
            suggest = "ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingSplunkConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingSplunkConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingSplunkConfig.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectLoggingSyslogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCert":
            suggest = "client_cert"
        elif key == "clientKey":
            suggest = "client_key"
        elif key == "enableTls":
            suggest = "enable_tls"
        elif key == "sslVerify":
            suggest = "ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectLoggingSyslogConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectLoggingSyslogConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectLoggingSyslogConfig.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@pulumi.output_type
class ProjectResourceQuota(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "namespaceDefaultLimit":
            suggest = "namespace_default_limit"
        elif key == "projectLimit":
            suggest = "project_limit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectResourceQuota. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectResourceQuota.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectResourceQuota.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectResourceQuotaNamespaceDefaultLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMaps":
            suggest = "config_maps"
        elif key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "persistentVolumeClaims":
            suggest = "persistent_volume_claims"
        elif key == "replicationControllers":
            suggest = "replication_controllers"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"
        elif key == "requestsStorage":
            suggest = "requests_storage"
        elif key == "servicesLoadBalancers":
            suggest = "services_load_balancers"
        elif key == "servicesNodePorts":
            suggest = "services_node_ports"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectResourceQuotaNamespaceDefaultLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectResourceQuotaNamespaceDefaultLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectResourceQuotaNamespaceDefaultLimit.__key_warning(key)
        return super().get(key, default)

    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")


@pulumi.output_type
class ProjectResourceQuotaProjectLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMaps":
            suggest = "config_maps"
        elif key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "persistentVolumeClaims":
            suggest = "persistent_volume_claims"
        elif key == "replicationControllers":
            suggest = "replication_controllers"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"
        elif key == "requestsStorage":
            suggest = "requests_storage"
        elif key == "servicesLoadBalancers":
            suggest = "services_load_balancers"
        elif key == "servicesNodePorts":
            suggest = "services_node_ports"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectResourceQuotaProjectLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectResourceQuotaProjectLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectResourceQuotaProjectLimit.__key_warning(key)
        return super().get(key, default)

    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")


@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")


@pulumi.output_type
class RoleTempalteRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroups":
            suggest = "api_groups"
        elif key == "nonResourceUrls":
            suggest = "non_resource_urls"
        elif key == "resourceNames":
            suggest = "resource_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RoleTempalteRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RoleTempalteRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RoleTempalteRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "api_groups")

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

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

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

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


@pulumi.output_type
class RoleTemplateRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroups":
            suggest = "api_groups"
        elif key == "nonResourceUrls":
            suggest = "non_resource_urls"
        elif key == "resourceNames":
            suggest = "resource_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RoleTemplateRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RoleTemplateRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RoleTemplateRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] api_groups: Policy rule api groups (list)
        :param Sequence[str] non_resource_urls: Policy rule non resource urls (list)
        :param Sequence[str] resource_names: Policy rule resource names (list)
        :param Sequence[str] resources: Policy rule resources (list)
        :param Sequence[str] verbs: Policy rule verbs. `bind`, `create`, `delete`, `deletecollection`, `escalate`, `get`, `impersonate`, `list`, `patch`, `update`, `use`, `view`, `watch`, `own` 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[Sequence[str]]:
        """
        Policy rule api groups (list)
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[str]]:
        """
        Policy rule non resource urls (list)
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[str]]:
        """
        Policy rule resource names (list)
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[str]]:
        """
        Policy rule resources (list)
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[str]]:
        """
        Policy rule verbs. `bind`, `create`, `delete`, `deletecollection`, `escalate`, `get`, `impersonate`, `list`, `patch`, `update`, `use`, `view`, `watch`, `own` and `*` values are supported (list)
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetClusterAksConfigResult(dict):
    def __init__(__self__, *,
                 agent_dns_prefix: str,
                 client_id: str,
                 client_secret: str,
                 kubernetes_version: str,
                 load_balancer_sku: str,
                 master_dns_prefix: str,
                 resource_group: str,
                 ssh_public_key_contents: str,
                 subnet: str,
                 subscription_id: str,
                 tag: Mapping[str, Any],
                 tags: Sequence[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[int] = 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[int] = 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[int] = 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__, "load_balancer_sku", load_balancer_sku)
        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__, "tags", tags)
        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="loadBalancerSku")
    def load_balancer_sku(self) -> str:
        return pulumi.get(self, "load_balancer_sku")

    @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
    def tags(self) -> Sequence[str]:
        return pulumi.get(self, "tags")

    @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[int]:
        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[int]:
        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[int]:
        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 GetClusterAksConfigV2Result(dict):
    def __init__(__self__, *,
                 cloud_credential_id: str,
                 http_application_routing: bool,
                 linux_admin_username: str,
                 linux_ssh_public_key: str,
                 load_balancer_sku: str,
                 log_analytics_workspace_group: str,
                 log_analytics_workspace_name: str,
                 monitoring: bool,
                 name: str,
                 network_dns_service_ip: str,
                 network_docker_bridge_cidr: str,
                 network_pod_cidr: str,
                 network_policy: str,
                 network_service_cidr: str,
                 private_cluster: bool,
                 resource_group: str,
                 resource_location: str,
                 subnet: str,
                 tags: Mapping[str, Any],
                 virtual_network: str,
                 virtual_network_resource_group: str,
                 auth_base_url: Optional[str] = None,
                 authorized_ip_ranges: Optional[Sequence[str]] = None,
                 base_url: Optional[str] = None,
                 dns_prefix: Optional[str] = None,
                 imported: Optional[bool] = None,
                 kubernetes_version: Optional[str] = None,
                 network_plugin: Optional[str] = None,
                 node_pools: Optional[Sequence['outputs.GetClusterAksConfigV2NodePoolResult']] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        pulumi.set(__self__, "http_application_routing", http_application_routing)
        pulumi.set(__self__, "linux_admin_username", linux_admin_username)
        pulumi.set(__self__, "linux_ssh_public_key", linux_ssh_public_key)
        pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        pulumi.set(__self__, "log_analytics_workspace_group", log_analytics_workspace_group)
        pulumi.set(__self__, "log_analytics_workspace_name", log_analytics_workspace_name)
        pulumi.set(__self__, "monitoring", monitoring)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_dns_service_ip", network_dns_service_ip)
        pulumi.set(__self__, "network_docker_bridge_cidr", network_docker_bridge_cidr)
        pulumi.set(__self__, "network_pod_cidr", network_pod_cidr)
        pulumi.set(__self__, "network_policy", network_policy)
        pulumi.set(__self__, "network_service_cidr", network_service_cidr)
        pulumi.set(__self__, "private_cluster", private_cluster)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "resource_location", resource_location)
        pulumi.set(__self__, "subnet", subnet)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "virtual_network", virtual_network)
        pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if authorized_ip_ranges is not None:
            pulumi.set(__self__, "authorized_ip_ranges", authorized_ip_ranges)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if dns_prefix is not None:
            pulumi.set(__self__, "dns_prefix", dns_prefix)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)

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

    @property
    @pulumi.getter(name="httpApplicationRouting")
    def http_application_routing(self) -> bool:
        return pulumi.get(self, "http_application_routing")

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="privateCluster")
    def private_cluster(self) -> bool:
        return pulumi.get(self, "private_cluster")

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

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

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

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

    @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="authBaseUrl")
    def auth_base_url(self) -> Optional[str]:
        return pulumi.get(self, "auth_base_url")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Optional[Sequence['outputs.GetClusterAksConfigV2NodePoolResult']]:
        return pulumi.get(self, "node_pools")


@pulumi.output_type
class GetClusterAksConfigV2NodePoolResult(dict):
    def __init__(__self__, *,
                 name: str,
                 vm_size: str,
                 availability_zones: Optional[Sequence[str]] = None,
                 count: Optional[int] = None,
                 enable_auto_scaling: Optional[bool] = None,
                 max_count: Optional[int] = None,
                 max_pods: Optional[int] = None,
                 min_count: Optional[int] = None,
                 mode: Optional[str] = None,
                 orchestrator_version: Optional[str] = None,
                 os_disk_size_gb: Optional[int] = None,
                 os_disk_type: Optional[str] = None,
                 os_type: Optional[str] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "vm_size", vm_size)
        if availability_zones is not None:
            pulumi.set(__self__, "availability_zones", availability_zones)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if enable_auto_scaling is not None:
            pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
        if max_count is not None:
            pulumi.set(__self__, "max_count", max_count)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if orchestrator_version is not None:
            pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if os_disk_type is not None:
            pulumi.set(__self__, "os_disk_type", os_disk_type)
        if os_type is not None:
            pulumi.set(__self__, "os_type", os_type)

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

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

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

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

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

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

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

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

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

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

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

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

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


@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[int] = None,
                 mem_threshold: Optional[int] = 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[int]:
        return pulumi.get(self, "cpu_threshold")

    @property
    @pulumi.getter(name="memThreshold")
    def mem_threshold(self) -> Optional[int]:
        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,
                 insecure_node_command: str,
                 insecure_windows_node_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__, "insecure_node_command", insecure_node_command)
        pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_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(name="insecureNodeCommand")
    def insecure_node_command(self) -> str:
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> str:
        return pulumi.get(self, "insecure_windows_node_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[int] = None,
                 ebs_encryption: Optional[bool] = None,
                 instance_type: Optional[str] = None,
                 key_pair_name: Optional[str] = None,
                 maximum_nodes: Optional[int] = None,
                 minimum_nodes: Optional[int] = None,
                 node_volume_size: Optional[int] = None,
                 region: Optional[str] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 service_role: Optional[str] = None,
                 session_token: Optional[str] = None,
                 subnets: Optional[Sequence[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 ebs_encryption is not None:
            pulumi.set(__self__, "ebs_encryption", ebs_encryption)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if key_pair_name is not None:
            pulumi.set(__self__, "key_pair_name", key_pair_name)
        if maximum_nodes is not None:
            pulumi.set(__self__, "maximum_nodes", maximum_nodes)
        if minimum_nodes is not None:
            pulumi.set(__self__, "minimum_nodes", minimum_nodes)
        if node_volume_size is not None:
            pulumi.set(__self__, "node_volume_size", node_volume_size)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if service_role is not None:
            pulumi.set(__self__, "service_role", service_role)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if 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[int]:
        return pulumi.get(self, "desired_nodes")

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

    @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[int]:
        return pulumi.get(self, "maximum_nodes")

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

    @property
    @pulumi.getter(name="nodeVolumeSize")
    def node_volume_size(self) -> Optional[int]:
        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[Sequence[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[Sequence[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 GetClusterEksConfigV2Result(dict):
    def __init__(__self__, *,
                 cloud_credential_id: str,
                 kubernetes_version: str,
                 name: str,
                 node_groups: Sequence['outputs.GetClusterEksConfigV2NodeGroupResult'],
                 private_access: bool,
                 public_access: bool,
                 public_access_sources: Sequence[str],
                 secrets_encryption: bool,
                 imported: Optional[bool] = None,
                 kms_key: Optional[str] = None,
                 logging_types: Optional[Sequence[str]] = None,
                 region: Optional[str] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 service_role: Optional[str] = None,
                 subnets: Optional[Sequence[str]] = None,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "node_groups", node_groups)
        pulumi.set(__self__, "private_access", private_access)
        pulumi.set(__self__, "public_access", public_access)
        pulumi.set(__self__, "public_access_sources", public_access_sources)
        pulumi.set(__self__, "secrets_encryption", secrets_encryption)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if logging_types is not None:
            pulumi.set(__self__, "logging_types", logging_types)
        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 subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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

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

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

    @property
    @pulumi.getter(name="nodeGroups")
    def node_groups(self) -> Sequence['outputs.GetClusterEksConfigV2NodeGroupResult']:
        return pulumi.get(self, "node_groups")

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> bool:
        return pulumi.get(self, "private_access")

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> bool:
        return pulumi.get(self, "public_access")

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

    @property
    @pulumi.getter(name="secretsEncryption")
    def secrets_encryption(self) -> bool:
        return pulumi.get(self, "secrets_encryption")

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

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

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

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

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence[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
    def subnets(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "subnets")

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


@pulumi.output_type
class GetClusterEksConfigV2NodeGroupResult(dict):
    def __init__(__self__, *,
                 name: str,
                 subnets: Sequence[str],
                 user_data: str,
                 version: str,
                 desired_size: Optional[int] = None,
                 disk_size: Optional[int] = None,
                 ec2_ssh_key: Optional[str] = None,
                 gpu: Optional[bool] = None,
                 image_id: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 launch_templates: Optional[Sequence['outputs.GetClusterEksConfigV2NodeGroupLaunchTemplateResult']] = None,
                 max_size: Optional[int] = None,
                 min_size: Optional[int] = None,
                 request_spot_instances: Optional[bool] = None,
                 resource_tags: Optional[Mapping[str, Any]] = None,
                 spot_instance_types: Optional[Sequence[str]] = None,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str name: The name of the Cluster (string)
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subnets", subnets)
        pulumi.set(__self__, "user_data", user_data)
        pulumi.set(__self__, "version", version)
        if desired_size is not None:
            pulumi.set(__self__, "desired_size", desired_size)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if ec2_ssh_key is not None:
            pulumi.set(__self__, "ec2_ssh_key", ec2_ssh_key)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if launch_templates is not None:
            pulumi.set(__self__, "launch_templates", launch_templates)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if request_spot_instances is not None:
            pulumi.set(__self__, "request_spot_instances", request_spot_instances)
        if resource_tags is not None:
            pulumi.set(__self__, "resource_tags", resource_tags)
        if spot_instance_types is not None:
            pulumi.set(__self__, "spot_instance_types", spot_instance_types)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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

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

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

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

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

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

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

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

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

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

    @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="launchTemplates")
    def launch_templates(self) -> Optional[Sequence['outputs.GetClusterEksConfigV2NodeGroupLaunchTemplateResult']]:
        return pulumi.get(self, "launch_templates")

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

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

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

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

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

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


@pulumi.output_type
class GetClusterEksConfigV2NodeGroupLaunchTemplateResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 version: Optional[int] = None):
        """
        :param str id: (Computed) The ID of the resource (string)
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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

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


@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: Sequence[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: Sequence[str],
                 project_id: str,
                 resource_labels: Mapping[str, Any],
                 service_account: str,
                 sub_network: str,
                 description: Optional[str] = None,
                 disk_size_gb: Optional[int] = 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[int] = None,
                 master_authorized_network_cidr_blocks: Optional[Sequence[str]] = None,
                 max_node_count: Optional[int] = None,
                 min_node_count: Optional[int] = None,
                 node_count: Optional[int] = None,
                 preemptible: Optional[bool] = None,
                 region: Optional[str] = None,
                 taints: Optional[Sequence[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) -> Sequence[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) -> Sequence[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[int]:
        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[int]:
        return pulumi.get(self, "local_ssd_count")

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

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

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

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[int]:
        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[Sequence[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 GetClusterGkeConfigV2Result(dict):
    def __init__(__self__, *,
                 cluster_addons: 'outputs.GetClusterGkeConfigV2ClusterAddonsResult',
                 cluster_ipv4_cidr_block: str,
                 description: str,
                 enable_kubernetes_alpha: bool,
                 google_credential_secret: str,
                 ip_allocation_policy: 'outputs.GetClusterGkeConfigV2IpAllocationPolicyResult',
                 kubernetes_version: str,
                 labels: Mapping[str, Any],
                 locations: Sequence[str],
                 logging_service: str,
                 maintenance_window: str,
                 master_authorized_networks_config: 'outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult',
                 monitoring_service: str,
                 name: str,
                 network: str,
                 network_policy_enabled: bool,
                 node_pools: Sequence['outputs.GetClusterGkeConfigV2NodePoolResult'],
                 private_cluster_config: 'outputs.GetClusterGkeConfigV2PrivateClusterConfigResult',
                 project_id: str,
                 region: str,
                 subnetwork: str,
                 zone: str,
                 imported: Optional[bool] = None):
        """
        :param str description: (Computed) The description for Cluster (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__, "cluster_addons", cluster_addons)
        pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "enable_kubernetes_alpha", enable_kubernetes_alpha)
        pulumi.set(__self__, "google_credential_secret", google_credential_secret)
        pulumi.set(__self__, "ip_allocation_policy", ip_allocation_policy)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "locations", locations)
        pulumi.set(__self__, "logging_service", logging_service)
        pulumi.set(__self__, "maintenance_window", maintenance_window)
        pulumi.set(__self__, "master_authorized_networks_config", master_authorized_networks_config)
        pulumi.set(__self__, "monitoring_service", monitoring_service)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "network_policy_enabled", network_policy_enabled)
        pulumi.set(__self__, "node_pools", node_pools)
        pulumi.set(__self__, "private_cluster_config", private_cluster_config)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "subnetwork", subnetwork)
        pulumi.set(__self__, "zone", zone)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)

    @property
    @pulumi.getter(name="clusterAddons")
    def cluster_addons(self) -> 'outputs.GetClusterGkeConfigV2ClusterAddonsResult':
        return pulumi.get(self, "cluster_addons")

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

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableKubernetesAlpha")
    def enable_kubernetes_alpha(self) -> bool:
        return pulumi.get(self, "enable_kubernetes_alpha")

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

    @property
    @pulumi.getter(name="ipAllocationPolicy")
    def ip_allocation_policy(self) -> 'outputs.GetClusterGkeConfigV2IpAllocationPolicyResult':
        return pulumi.get(self, "ip_allocation_policy")

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

    @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) -> Sequence[str]:
        return pulumi.get(self, "locations")

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

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

    @property
    @pulumi.getter(name="masterAuthorizedNetworksConfig")
    def master_authorized_networks_config(self) -> 'outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult':
        return pulumi.get(self, "master_authorized_networks_config")

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

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

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

    @property
    @pulumi.getter(name="networkPolicyEnabled")
    def network_policy_enabled(self) -> bool:
        return pulumi.get(self, "network_policy_enabled")

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Sequence['outputs.GetClusterGkeConfigV2NodePoolResult']:
        return pulumi.get(self, "node_pools")

    @property
    @pulumi.getter(name="privateClusterConfig")
    def private_cluster_config(self) -> 'outputs.GetClusterGkeConfigV2PrivateClusterConfigResult':
        return pulumi.get(self, "private_cluster_config")

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

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

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

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

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


@pulumi.output_type
class GetClusterGkeConfigV2ClusterAddonsResult(dict):
    def __init__(__self__, *,
                 horizontal_pod_autoscaling: bool,
                 http_load_balancing: bool,
                 network_policy_config: bool):
        pulumi.set(__self__, "horizontal_pod_autoscaling", horizontal_pod_autoscaling)
        pulumi.set(__self__, "http_load_balancing", http_load_balancing)
        pulumi.set(__self__, "network_policy_config", network_policy_config)

    @property
    @pulumi.getter(name="horizontalPodAutoscaling")
    def horizontal_pod_autoscaling(self) -> bool:
        return pulumi.get(self, "horizontal_pod_autoscaling")

    @property
    @pulumi.getter(name="httpLoadBalancing")
    def http_load_balancing(self) -> bool:
        return pulumi.get(self, "http_load_balancing")

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> bool:
        return pulumi.get(self, "network_policy_config")


@pulumi.output_type
class GetClusterGkeConfigV2IpAllocationPolicyResult(dict):
    def __init__(__self__, *,
                 cluster_ipv4_cidr_block: str,
                 cluster_secondary_range_name: str,
                 create_subnetwork: bool,
                 node_ipv4_cidr_block: str,
                 services_ipv4_cidr_block: str,
                 services_secondary_range_name: str,
                 subnetwork_name: str,
                 use_ip_aliases: bool):
        pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        pulumi.set(__self__, "create_subnetwork", create_subnetwork)
        pulumi.set(__self__, "node_ipv4_cidr_block", node_ipv4_cidr_block)
        pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        pulumi.set(__self__, "subnetwork_name", subnetwork_name)
        pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)

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

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

    @property
    @pulumi.getter(name="createSubnetwork")
    def create_subnetwork(self) -> bool:
        return pulumi.get(self, "create_subnetwork")

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

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

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

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

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> bool:
        return pulumi.get(self, "use_ip_aliases")


@pulumi.output_type
class GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult(dict):
    def __init__(__self__, *,
                 cidr_blocks: Sequence['outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult'],
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> Sequence['outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult']:
        return pulumi.get(self, "cidr_blocks")

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


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

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

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


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolResult(dict):
    def __init__(__self__, *,
                 autoscaling: 'outputs.GetClusterGkeConfigV2NodePoolAutoscalingResult',
                 config: 'outputs.GetClusterGkeConfigV2NodePoolConfigResult',
                 initial_node_count: int,
                 management: 'outputs.GetClusterGkeConfigV2NodePoolManagementResult',
                 max_pods_constraint: int,
                 name: str,
                 version: str):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "autoscaling", autoscaling)
        pulumi.set(__self__, "config", config)
        pulumi.set(__self__, "initial_node_count", initial_node_count)
        pulumi.set(__self__, "management", management)
        pulumi.set(__self__, "max_pods_constraint", max_pods_constraint)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def autoscaling(self) -> 'outputs.GetClusterGkeConfigV2NodePoolAutoscalingResult':
        return pulumi.get(self, "autoscaling")

    @property
    @pulumi.getter
    def config(self) -> 'outputs.GetClusterGkeConfigV2NodePoolConfigResult':
        return pulumi.get(self, "config")

    @property
    @pulumi.getter(name="initialNodeCount")
    def initial_node_count(self) -> int:
        return pulumi.get(self, "initial_node_count")

    @property
    @pulumi.getter
    def management(self) -> 'outputs.GetClusterGkeConfigV2NodePoolManagementResult':
        return pulumi.get(self, "management")

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> int:
        return pulumi.get(self, "max_pods_constraint")

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

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


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolAutoscalingResult(dict):
    def __init__(__self__, *,
                 max_node_count: int,
                 min_node_count: int,
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "max_node_count", max_node_count)
        pulumi.set(__self__, "min_node_count", min_node_count)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> int:
        return pulumi.get(self, "max_node_count")

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> int:
        return pulumi.get(self, "min_node_count")

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


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolConfigResult(dict):
    def __init__(__self__, *,
                 labels: Mapping[str, Any],
                 oauth_scopes: Sequence[str],
                 tags: Sequence[str],
                 disk_size_gb: Optional[int] = None,
                 disk_type: Optional[str] = None,
                 image_type: Optional[str] = None,
                 local_ssd_count: Optional[int] = None,
                 machine_type: Optional[str] = None,
                 preemptible: Optional[bool] = None,
                 taints: Optional[Sequence['outputs.GetClusterGkeConfigV2NodePoolConfigTaintResult']] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        """
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        pulumi.set(__self__, "tags", tags)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

    @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="oauthScopes")
    def oauth_scopes(self) -> Sequence[str]:
        return pulumi.get(self, "oauth_scopes")

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolConfigTaintResult(dict):
    def __init__(__self__, *,
                 effect: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolManagementResult(dict):
    def __init__(__self__, *,
                 auto_repair: bool,
                 auto_upgrade: bool):
        pulumi.set(__self__, "auto_repair", auto_repair)
        pulumi.set(__self__, "auto_upgrade", auto_upgrade)

    @property
    @pulumi.getter(name="autoRepair")
    def auto_repair(self) -> bool:
        return pulumi.get(self, "auto_repair")

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> bool:
        return pulumi.get(self, "auto_upgrade")


@pulumi.output_type
class GetClusterGkeConfigV2PrivateClusterConfigResult(dict):
    def __init__(__self__, *,
                 master_ipv4_cidr_block: str,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None):
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)

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

    @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")


@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[int] = None,
                 worker_concurrency: Optional[int] = 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[int]:
        return pulumi.get(self, "server_concurrency")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[int]:
        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: Sequence['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) -> Sequence['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[int] = 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[int]:
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetClusterLoggingKafkaConfigResult(dict):
    def __init__(__self__, *,
                 topic: str,
                 broker_endpoints: Optional[Sequence[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[Sequence[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 GetClusterOkeConfigResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 fingerprint: str,
                 kubernetes_version: str,
                 node_image: str,
                 node_shape: str,
                 private_key_contents: str,
                 region: str,
                 tenancy_id: str,
                 user_ocid: str,
                 custom_boot_volume_size: Optional[int] = None,
                 description: Optional[str] = None,
                 enable_kubernetes_dashboard: Optional[bool] = None,
                 enable_private_control_plane: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None,
                 flex_ocpus: Optional[int] = None,
                 kms_key_id: Optional[str] = None,
                 limit_node_count: Optional[int] = None,
                 load_balancer_subnet_name1: Optional[str] = None,
                 load_balancer_subnet_name2: Optional[str] = None,
                 node_pool_dns_domain_name: Optional[str] = None,
                 node_pool_subnet_name: Optional[str] = None,
                 node_public_key_contents: Optional[str] = None,
                 pod_cidr: Optional[str] = None,
                 private_key_passphrase: Optional[str] = None,
                 quantity_of_node_subnets: Optional[int] = None,
                 quantity_per_subnet: Optional[int] = None,
                 service_cidr: Optional[str] = None,
                 service_dns_domain_name: Optional[str] = None,
                 skip_vcn_delete: Optional[bool] = None,
                 vcn_compartment_id: Optional[str] = None,
                 vcn_name: Optional[str] = None,
                 worker_node_ingress_cidr: Optional[str] = None):
        """
        :param str description: (Computed) The description for Cluster (string)
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "fingerprint", fingerprint)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "node_image", node_image)
        pulumi.set(__self__, "node_shape", node_shape)
        pulumi.set(__self__, "private_key_contents", private_key_contents)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenancy_id", tenancy_id)
        pulumi.set(__self__, "user_ocid", user_ocid)
        if custom_boot_volume_size is not None:
            pulumi.set(__self__, "custom_boot_volume_size", custom_boot_volume_size)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_dashboard is not None:
            pulumi.set(__self__, "enable_kubernetes_dashboard", enable_kubernetes_dashboard)
        if enable_private_control_plane is not None:
            pulumi.set(__self__, "enable_private_control_plane", enable_private_control_plane)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if flex_ocpus is not None:
            pulumi.set(__self__, "flex_ocpus", flex_ocpus)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if limit_node_count is not None:
            pulumi.set(__self__, "limit_node_count", limit_node_count)
        if load_balancer_subnet_name1 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name1", load_balancer_subnet_name1)
        if load_balancer_subnet_name2 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name2", load_balancer_subnet_name2)
        if node_pool_dns_domain_name is not None:
            pulumi.set(__self__, "node_pool_dns_domain_name", node_pool_dns_domain_name)
        if node_pool_subnet_name is not None:
            pulumi.set(__self__, "node_pool_subnet_name", node_pool_subnet_name)
        if node_public_key_contents is not None:
            pulumi.set(__self__, "node_public_key_contents", node_public_key_contents)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if private_key_passphrase is not None:
            pulumi.set(__self__, "private_key_passphrase", private_key_passphrase)
        if quantity_of_node_subnets is not None:
            pulumi.set(__self__, "quantity_of_node_subnets", quantity_of_node_subnets)
        if quantity_per_subnet is not None:
            pulumi.set(__self__, "quantity_per_subnet", quantity_per_subnet)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)
        if service_dns_domain_name is not None:
            pulumi.set(__self__, "service_dns_domain_name", service_dns_domain_name)
        if skip_vcn_delete is not None:
            pulumi.set(__self__, "skip_vcn_delete", skip_vcn_delete)
        if vcn_compartment_id is not None:
            pulumi.set(__self__, "vcn_compartment_id", vcn_compartment_id)
        if vcn_name is not None:
            pulumi.set(__self__, "vcn_name", vcn_name)
        if worker_node_ingress_cidr is not None:
            pulumi.set(__self__, "worker_node_ingress_cidr", worker_node_ingress_cidr)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetClusterRke2ConfigResult(dict):
    def __init__(__self__, *,
                 upgrade_strategy: 'outputs.GetClusterRke2ConfigUpgradeStrategyResult',
                 version: str):
        pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        pulumi.set(__self__, "version", version)

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

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


@pulumi.output_type
class GetClusterRke2ConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_server_nodes: Optional[bool] = None,
                 drain_worker_nodes: Optional[bool] = None,
                 server_concurrency: Optional[int] = None,
                 worker_concurrency: Optional[int] = 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[int]:
        return pulumi.get(self, "server_concurrency")

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


@pulumi.output_type
class GetClusterRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: int,
                 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',
                 win_prefix_path: str,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[str]] = None,
                 enable_cri_dockerd: Optional[bool] = None,
                 ignore_docker_version: Optional[bool] = None,
                 nodes: Optional[Sequence['outputs.GetClusterRkeConfigNodeResult']] = None,
                 private_registries: Optional[Sequence['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)
        pulumi.set(__self__, "win_prefix_path", win_prefix_path)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if 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) -> int:
        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(name="winPrefixPath")
    def win_prefix_path(self) -> str:
        return pulumi.get(self, "win_prefix_path")

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

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

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

    @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[Sequence['outputs.GetClusterRkeConfigNodeResult']]:
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[Sequence['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: Sequence[str],
                 strategy: str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Sequence[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,
                 aws_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 name: Optional[str] = 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)
        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 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="customCloudProvider")
    def custom_cloud_provider(self) -> str:
        return pulumi.get(self, "custom_cloud_provider")

    @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
    def name(self) -> Optional[str]:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @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[Sequence['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[Sequence['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: int,
                 cloud_provider_backoff_exponent: int,
                 cloud_provider_backoff_jitter: int,
                 cloud_provider_backoff_retries: int,
                 cloud_provider_rate_limit: bool,
                 cloud_provider_rate_limit_bucket: int,
                 cloud_provider_rate_limit_qps: int,
                 location: str,
                 maximum_load_balancer_rule_count: int,
                 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) -> int:
        return pulumi.get(self, "cloud_provider_backoff_duration")

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

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

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> int:
        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) -> int:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> int:
        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) -> int:
        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[int] = 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[int]:
        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: int,
                 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) -> int:
        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: Sequence['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) -> Sequence['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: int,
                 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) -> int:
        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: int,
                 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) -> int:
        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],
                 options: Mapping[str, Any],
                 reverse_cidrs: Sequence[str],
                 upstream_nameservers: Sequence[str],
                 linear_autoscaler_params: Optional['outputs.GetClusterRkeConfigDnsLinearAutoscalerParamsResult'] = None,
                 nodelocal: Optional['outputs.GetClusterRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigDnsTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyResult'] = None):
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="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(name="reverseCidrs")
    def reverse_cidrs(self) -> Sequence[str]:
        return pulumi.get(self, "reverse_cidrs")

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

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.GetClusterRkeConfigDnsLinearAutoscalerParamsResult']:
        return pulumi.get(self, "linear_autoscaler_params")

    @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")

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

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


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

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

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

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

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

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


@pulumi.output_type
class GetClusterRkeConfigDnsUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult'] = 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.GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

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


@pulumi.output_type
class GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = 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[int]:
        return pulumi.get(self, "max_surge")

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


@pulumi.output_type
class GetClusterRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: str,
                 extra_args: Mapping[str, Any],
                 http_port: int,
                 https_port: int,
                 network_mode: str,
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 provider: str,
                 default_backend: Optional[bool] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigIngressTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyResult'] = None):
        pulumi.set(__self__, "dns_policy", dns_policy)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "http_port", http_port)
        pulumi.set(__self__, "https_port", https_port)
        pulumi.set(__self__, "network_mode", network_mode)
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "provider", provider)
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="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="httpPort")
    def http_port(self) -> int:
        return pulumi.get(self, "http_port")

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

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

    @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")

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

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

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


@pulumi.output_type
class GetClusterRkeConfigIngressUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult'] = 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.GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

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


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

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


@pulumi.output_type
class GetClusterRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 provider: str,
                 replicas: int,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigMonitoringTolerationResult']] = 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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter
    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) -> int:
        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
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigMonitoringTolerationResult']]:
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


@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[int] = None,
                 max_unavailable: Optional[int] = 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[int]:
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[int]:
        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[int] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigNetworkTolerationResult']] = 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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

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

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

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

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

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

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

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

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


@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: Sequence[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) -> Sequence[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,
                 ecr_credential_plugin: Optional['outputs.GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

    @property
    @pulumi.getter(name="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional['outputs.GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult']:
        return pulumi.get(self, "ecr_credential_plugin")

    @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 GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult(dict):
    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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


@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[Sequence[str]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 uid: Optional[int] = None):
        """
        :param str ca_cert: (Computed) K8s cluster ca cert (string)
        """
        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:
        """
        (Computed) K8s cluster ca cert (string)
        """
        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[Sequence[str]]:
        return pulumi.get(self, "external_urls")

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

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

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

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


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: int,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = None):
        pulumi.set(__self__, "timeout", timeout)
        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 timeout(self) -> int:
        return pulumi.get(self, "timeout")

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

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

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = 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[int]:
        return pulumi.get(self, "max_age")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        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__, *,
                 configuration: str,
                 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) -> str:
        return pulumi.get(self, "configuration")

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


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 custom_config: str,
                 enabled: Optional[bool] = 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) -> str:
        return pulumi.get(self, "custom_config")

    @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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[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[int]:
        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[int]:
        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[Sequence[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 Sequence[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[Sequence[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[Sequence[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[Sequence[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: int):
        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) -> int:
        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[Sequence['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[Sequence['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: int,
                 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',
                 win_prefix_path: str,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[str]] = None,
                 enable_cri_dockerd: Optional[bool] = None,
                 ignore_docker_version: Optional[bool] = None,
                 nodes: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']] = None,
                 private_registries: Optional[Sequence['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)
        pulumi.set(__self__, "win_prefix_path", win_prefix_path)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if 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) -> int:
        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(name="winPrefixPath")
    def win_prefix_path(self) -> str:
        return pulumi.get(self, "win_prefix_path")

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

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

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

    @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[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']]:
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[Sequence['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: Sequence[str],
                 strategy: str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Sequence[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,
                 aws_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 name: Optional[str] = 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)
        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 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="customCloudProvider")
    def custom_cloud_provider(self) -> str:
        return pulumi.get(self, "custom_cloud_provider")

    @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
    def name(self) -> Optional[str]:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @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[Sequence['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[Sequence['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: int,
                 cloud_provider_backoff_exponent: int,
                 cloud_provider_backoff_jitter: int,
                 cloud_provider_backoff_retries: int,
                 cloud_provider_rate_limit: bool,
                 cloud_provider_rate_limit_bucket: int,
                 cloud_provider_rate_limit_qps: int,
                 location: str,
                 maximum_load_balancer_rule_count: int,
                 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) -> int:
        return pulumi.get(self, "cloud_provider_backoff_duration")

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

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

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> int:
        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) -> int:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> int:
        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) -> int:
        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[int] = 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[int]:
        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: int,
                 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) -> int:
        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: Sequence['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) -> Sequence['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: int,
                 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) -> int:
        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: int,
                 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) -> int:
        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],
                 options: Mapping[str, Any],
                 reverse_cidrs: Sequence[str],
                 upstream_nameservers: Sequence[str],
                 linear_autoscaler_params: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult'] = None,
                 nodelocal: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult'] = None):
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="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(name="reverseCidrs")
    def reverse_cidrs(self) -> Sequence[str]:
        return pulumi.get(self, "reverse_cidrs")

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

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult']:
        return pulumi.get(self, "linear_autoscaler_params")

    @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")

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

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


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

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

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

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

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

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult'] = 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.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = 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[int]:
        return pulumi.get(self, "max_surge")

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: str,
                 extra_args: Mapping[str, Any],
                 http_port: int,
                 https_port: int,
                 network_mode: str,
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 provider: str,
                 default_backend: Optional[bool] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult'] = None):
        pulumi.set(__self__, "dns_policy", dns_policy)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "http_port", http_port)
        pulumi.set(__self__, "https_port", https_port)
        pulumi.set(__self__, "network_mode", network_mode)
        pulumi.set(__self__, "node_selector", node_selector)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "provider", provider)
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="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="httpPort")
    def http_port(self) -> int:
        return pulumi.get(self, "http_port")

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

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

    @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")

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

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

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult'] = 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.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

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


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

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 provider: str,
                 replicas: int,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult']] = 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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter
    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) -> int:
        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
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult']]:
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult']:
        return pulumi.get(self, "update_strategy")


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

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

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

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

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

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


@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[int] = None,
                 max_unavailable: Optional[int] = 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[int]:
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[int]:
        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[int] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult']] = 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 tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

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

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

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

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

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

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

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

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


@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: Sequence[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) -> Sequence[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,
                 ecr_credential_plugin: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

    @property
    @pulumi.getter(name="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult']:
        return pulumi.get(self, "ecr_credential_plugin")

    @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 GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult(dict):
    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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


@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[Sequence[str]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 uid: Optional[int] = 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[Sequence[str]]:
        return pulumi.get(self, "external_urls")

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

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

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

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: int,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = None):
        pulumi.set(__self__, "timeout", timeout)
        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 timeout(self) -> int:
        return pulumi.get(self, "timeout")

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

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

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = 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[int]:
        return pulumi.get(self, "max_age")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        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__, *,
                 configuration: str,
                 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) -> str:
        return pulumi.get(self, "configuration")

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


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 custom_config: str,
                 enabled: Optional[bool] = 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) -> str:
        return pulumi.get(self, "custom_config")

    @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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[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[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[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[int]:
        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[int]:
        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[Sequence[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[Sequence[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: int):
        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) -> int:
        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 GetClusterV2AgentEnvVarResult(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the Cluster v2 (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class GetClusterV2ClusterRegistrationTokenResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cluster_id: str,
                 command: str,
                 id: str,
                 insecure_command: str,
                 insecure_node_command: str,
                 insecure_windows_node_command: str,
                 labels: Mapping[str, Any],
                 manifest_url: str,
                 name: str,
                 node_command: str,
                 token: str,
                 windows_node_command: str):
        """
        :param str id: (Computed) The ID of the resource (string)
        :param str name: The name of the Cluster v2 (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__, "insecure_node_command", insecure_node_command)
        pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_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]:
        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(name="insecureNodeCommand")
    def insecure_node_command(self) -> str:
        return pulumi.get(self, "insecure_node_command")

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

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        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 v2 (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 GetClusterV2RkeConfigResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterV2RkeConfigEtcdResult',
                 machine_pools: Sequence['outputs.GetClusterV2RkeConfigMachinePoolResult'],
                 machine_selector_configs: Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigResult'],
                 additional_manifest: Optional[str] = None,
                 chart_values: Optional[str] = None,
                 local_auth_endpoint: Optional['outputs.GetClusterV2RkeConfigLocalAuthEndpointResult'] = None,
                 machine_global_config: Optional[str] = None,
                 registries: Optional['outputs.GetClusterV2RkeConfigRegistriesResult'] = None,
                 upgrade_strategy: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyResult'] = None):
        pulumi.set(__self__, "etcd", etcd)
        pulumi.set(__self__, "machine_pools", machine_pools)
        pulumi.set(__self__, "machine_selector_configs", machine_selector_configs)
        if additional_manifest is not None:
            pulumi.set(__self__, "additional_manifest", additional_manifest)
        if chart_values is not None:
            pulumi.set(__self__, "chart_values", chart_values)
        if local_auth_endpoint is not None:
            pulumi.set(__self__, "local_auth_endpoint", local_auth_endpoint)
        if machine_global_config is not None:
            pulumi.set(__self__, "machine_global_config", machine_global_config)
        if registries is not None:
            pulumi.set(__self__, "registries", registries)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter
    def etcd(self) -> 'outputs.GetClusterV2RkeConfigEtcdResult':
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="machinePools")
    def machine_pools(self) -> Sequence['outputs.GetClusterV2RkeConfigMachinePoolResult']:
        return pulumi.get(self, "machine_pools")

    @property
    @pulumi.getter(name="machineSelectorConfigs")
    def machine_selector_configs(self) -> Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigResult']:
        return pulumi.get(self, "machine_selector_configs")

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

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

    @property
    @pulumi.getter(name="localAuthEndpoint")
    def local_auth_endpoint(self) -> Optional['outputs.GetClusterV2RkeConfigLocalAuthEndpointResult']:
        return pulumi.get(self, "local_auth_endpoint")

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

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

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


@pulumi.output_type
class GetClusterV2RkeConfigEtcdResult(dict):
    def __init__(__self__, *,
                 disable_snapshots: Optional[bool] = None,
                 s3_config: Optional['outputs.GetClusterV2RkeConfigEtcdS3ConfigResult'] = None,
                 snapshot_retention: Optional[int] = None,
                 snapshot_schedule_cron: Optional[str] = None):
        if disable_snapshots is not None:
            pulumi.set(__self__, "disable_snapshots", disable_snapshots)
        if s3_config is not None:
            pulumi.set(__self__, "s3_config", s3_config)
        if snapshot_retention is not None:
            pulumi.set(__self__, "snapshot_retention", snapshot_retention)
        if snapshot_schedule_cron is not None:
            pulumi.set(__self__, "snapshot_schedule_cron", snapshot_schedule_cron)

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

    @property
    @pulumi.getter(name="s3Config")
    def s3_config(self) -> Optional['outputs.GetClusterV2RkeConfigEtcdS3ConfigResult']:
        return pulumi.get(self, "s3_config")

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

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


@pulumi.output_type
class GetClusterV2RkeConfigEtcdS3ConfigResult(dict):
    def __init__(__self__, *,
                 bucket: str,
                 endpoint: str,
                 cloud_credential_name: Optional[str] = None,
                 endpoint_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 skip_ssl_verify: Optional[bool] = None):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "endpoint", endpoint)
        if cloud_credential_name is not None:
            pulumi.set(__self__, "cloud_credential_name", cloud_credential_name)
        if endpoint_ca is not None:
            pulumi.set(__self__, "endpoint_ca", endpoint_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if skip_ssl_verify is not None:
            pulumi.set(__self__, "skip_ssl_verify", skip_ssl_verify)

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

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

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

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[str]:
        return pulumi.get(self, "endpoint_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="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[bool]:
        return pulumi.get(self, "skip_ssl_verify")


@pulumi.output_type
class GetClusterV2RkeConfigLocalAuthEndpointResult(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 GetClusterV2RkeConfigMachinePoolResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cloud_credential_secret_name: str,
                 labels: Mapping[str, Any],
                 machine_config: 'outputs.GetClusterV2RkeConfigMachinePoolMachineConfigResult',
                 name: str,
                 control_plane_role: Optional[bool] = None,
                 etcd_role: Optional[bool] = None,
                 paused: Optional[bool] = None,
                 quantity: Optional[int] = None,
                 rolling_update: Optional['outputs.GetClusterV2RkeConfigMachinePoolRollingUpdateResult'] = None,
                 taints: Optional[Sequence['outputs.GetClusterV2RkeConfigMachinePoolTaintResult']] = None,
                 worker_role: Optional[bool] = None):
        """
        :param str cloud_credential_secret_name: (Computed) Cluster V2 cloud credential secret name (string)
        :param str name: The name of the Cluster v2 (string)
        """
        pulumi.set(__self__, "annotations", annotations)
        pulumi.set(__self__, "cloud_credential_secret_name", cloud_credential_secret_name)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "machine_config", machine_config)
        pulumi.set(__self__, "name", name)
        if control_plane_role is not None:
            pulumi.set(__self__, "control_plane_role", control_plane_role)
        if etcd_role is not None:
            pulumi.set(__self__, "etcd_role", etcd_role)
        if paused is not None:
            pulumi.set(__self__, "paused", paused)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if worker_role is not None:
            pulumi.set(__self__, "worker_role", worker_role)

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

    @property
    @pulumi.getter(name="cloudCredentialSecretName")
    def cloud_credential_secret_name(self) -> str:
        """
        (Computed) Cluster V2 cloud credential secret name (string)
        """
        return pulumi.get(self, "cloud_credential_secret_name")

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

    @property
    @pulumi.getter(name="machineConfig")
    def machine_config(self) -> 'outputs.GetClusterV2RkeConfigMachinePoolMachineConfigResult':
        return pulumi.get(self, "machine_config")

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

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

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

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

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

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterV2RkeConfigMachinePoolRollingUpdateResult']:
        return pulumi.get(self, "rolling_update")

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

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


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolMachineConfigResult(dict):
    def __init__(__self__, *,
                 kind: str,
                 name: str):
        """
        :param str name: The name of the Cluster v2 (string)
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "name", name)

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

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


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

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


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

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

    @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 GetClusterV2RkeConfigMachineSelectorConfigResult(dict):
    def __init__(__self__, *,
                 config: Optional[Mapping[str, Any]] = None,
                 machine_label_selector: Optional['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult'] = None):
        if config is not None:
            pulumi.set(__self__, "config", config)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

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

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult']:
        return pulumi.get(self, "machine_label_selector")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult(dict):
    def __init__(__self__, *,
                 match_expressions: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult']] = None,
                 match_labels: Optional[Mapping[str, Any]] = None):
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult']]:
        return pulumi.get(self, "match_expressions")

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


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 operator: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

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

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

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


@pulumi.output_type
class GetClusterV2RkeConfigRegistriesResult(dict):
    def __init__(__self__, *,
                 configs: Optional[Sequence['outputs.GetClusterV2RkeConfigRegistriesConfigResult']] = None,
                 mirrors: Optional[Sequence['outputs.GetClusterV2RkeConfigRegistriesMirrorResult']] = None):
        if configs is not None:
            pulumi.set(__self__, "configs", configs)
        if mirrors is not None:
            pulumi.set(__self__, "mirrors", mirrors)

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

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


@pulumi.output_type
class GetClusterV2RkeConfigRegistriesConfigResult(dict):
    def __init__(__self__, *,
                 hostname: str,
                 auth_config_secret_name: Optional[str] = None,
                 ca_bundle: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 tls_secret_name: Optional[str] = None):
        pulumi.set(__self__, "hostname", hostname)
        if auth_config_secret_name is not None:
            pulumi.set(__self__, "auth_config_secret_name", auth_config_secret_name)
        if ca_bundle is not None:
            pulumi.set(__self__, "ca_bundle", ca_bundle)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if tls_secret_name is not None:
            pulumi.set(__self__, "tls_secret_name", tls_secret_name)

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

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

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

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

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


@pulumi.output_type
class GetClusterV2RkeConfigRegistriesMirrorResult(dict):
    def __init__(__self__, *,
                 hostname: str,
                 endpoints: Optional[Sequence[str]] = None,
                 rewrites: Optional[Mapping[str, Any]] = None):
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

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

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

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


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 control_plane_concurrency: Optional[str] = None,
                 control_plane_drain_options: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult'] = None,
                 worker_concurrency: Optional[str] = None,
                 worker_drain_options: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult'] = None):
        if control_plane_concurrency is not None:
            pulumi.set(__self__, "control_plane_concurrency", control_plane_concurrency)
        if control_plane_drain_options is not None:
            pulumi.set(__self__, "control_plane_drain_options", control_plane_drain_options)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)
        if worker_drain_options is not None:
            pulumi.set(__self__, "worker_drain_options", worker_drain_options)

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

    @property
    @pulumi.getter(name="controlPlaneDrainOptions")
    def control_plane_drain_options(self) -> Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult']:
        return pulumi.get(self, "control_plane_drain_options")

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

    @property
    @pulumi.getter(name="workerDrainOptions")
    def worker_drain_options(self) -> Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult']:
        return pulumi.get(self, "worker_drain_options")


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult(dict):
    def __init__(__self__, *,
                 grace_period: int,
                 skip_wait_for_delete_timeout_seconds: int,
                 timeout: int,
                 delete_empty_dir_data: Optional[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None):
        pulumi.set(__self__, "grace_period", grace_period)
        pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        pulumi.set(__self__, "timeout", timeout)
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> int:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> int:
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

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

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

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

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

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

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

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


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult(dict):
    def __init__(__self__, *,
                 grace_period: int,
                 skip_wait_for_delete_timeout_seconds: int,
                 timeout: int,
                 delete_empty_dir_data: Optional[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None):
        pulumi.set(__self__, "grace_period", grace_period)
        pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        pulumi.set(__self__, "timeout", timeout)
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> int:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> int:
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

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

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

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

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

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

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

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


@pulumi.output_type
class GetEtcdBackupBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: int,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.GetEtcdBackupBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = None):
        pulumi.set(__self__, "timeout", timeout)
        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 timeout(self) -> int:
        return pulumi.get(self, "timeout")

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

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

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        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 GetGlobalDnsProviderAlidnsConfigResult(dict):
    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)

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

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


@pulumi.output_type
class GetGlobalDnsProviderCloudflareConfigResult(dict):
    def __init__(__self__, *,
                 api_email: str,
                 api_key: str,
                 proxy_setting: Optional[bool] = None):
        pulumi.set(__self__, "api_email", api_email)
        pulumi.set(__self__, "api_key", api_key)
        if proxy_setting is not None:
            pulumi.set(__self__, "proxy_setting", proxy_setting)

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

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

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


@pulumi.output_type
class GetGlobalDnsProviderRoute53ConfigResult(dict):
    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 credentials_path: Optional[str] = None,
                 region: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 zone_type: Optional[str] = None):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if credentials_path is not None:
            pulumi.set(__self__, "credentials_path", credentials_path)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if zone_type is not None:
            pulumi.set(__self__, "zone_type", zone_type)

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

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

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

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

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

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


@pulumi.output_type
class GetGlobalRoleRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "api_groups")

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

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

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

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


@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[int] = None,
                 interval: Optional[int] = 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[int]:
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        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 GetNodeTemplateNodeTaintResult(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 GetNotifierDingtalkConfigResult(dict):
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None,
                 secret: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

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

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

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


@pulumi.output_type
class GetNotifierMsteamsConfigResult(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 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: int,
                 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) -> int:
        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: Sequence['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) -> Sequence['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: int,
                 min: int):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class GetPodSecurityPolicyTemplateHostPortResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsGroupResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['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[Sequence['outputs.GetPodSecurityPolicyTemplateRunAsGroupRangeResult']]:
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsUserResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['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[Sequence['outputs.GetPodSecurityPolicyTemplateRunAsUserRangeResult']]:
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsUserRangeResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class GetPodSecurityPolicyTemplateRuntimeClassResult(dict):
    def __init__(__self__, *,
                 allowed_runtime_class_names: Sequence[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) -> Sequence[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: Sequence['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) -> Sequence['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: int,
                 min: int):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

    @property
    @pulumi.getter
    def min(self) -> int:
        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[int] = None,
                 restart_times: Optional[int] = 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[int]:
        return pulumi.get(self, "restart_interval_seconds")

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


@pulumi.output_type
class GetProjectAlertRuleWorkloadRuleResult(dict):
    def __init__(__self__, *,
                 available_percentage: Optional[int] = 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[int]:
        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: Sequence['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) -> Sequence['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[int] = 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[int]:
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetProjectLoggingKafkaConfigResult(dict):
    def __init__(__self__, *,
                 topic: str,
                 broker_endpoints: Optional[Sequence[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[Sequence[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[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "api_groups")

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

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

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

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


@pulumi.output_type
class GetRoleTemplateRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "api_groups")

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

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

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

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


