# 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 builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities
from . import outputs

__all__ = [
    'CloudCredentialAmazonec2CredentialConfig',
    'CloudCredentialAzureCredentialConfig',
    'CloudCredentialDigitaloceanCredentialConfig',
    'CloudCredentialGoogleCredentialConfig',
    'CloudCredentialHarvesterCredentialConfig',
    'CloudCredentialLinodeCredentialConfig',
    'CloudCredentialOpenstackCredentialConfig',
    'CloudCredentialS3CredentialConfig',
    'CloudCredentialVsphereCredentialConfig',
    'ClusterAgentEnvVar',
    'ClusterAksConfig',
    'ClusterAksConfigV2',
    'ClusterAksConfigV2NodePool',
    'ClusterClusterAgentDeploymentCustomization',
    'ClusterClusterAgentDeploymentCustomizationAppendToleration',
    'ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement',
    'ClusterClusterAgentDeploymentCustomizationSchedulingCustomization',
    'ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget',
    'ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass',
    'ClusterClusterAuthEndpoint',
    'ClusterClusterRegistrationToken',
    'ClusterClusterTemplateAnswers',
    'ClusterClusterTemplateQuestion',
    'ClusterEksConfig',
    'ClusterEksConfigV2',
    'ClusterEksConfigV2NodeGroup',
    'ClusterEksConfigV2NodeGroupLaunchTemplate',
    'ClusterFleetAgentDeploymentCustomization',
    'ClusterFleetAgentDeploymentCustomizationAppendToleration',
    'ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirement',
    'ClusterGkeConfig',
    'ClusterGkeConfigV2',
    'ClusterGkeConfigV2ClusterAddons',
    'ClusterGkeConfigV2IpAllocationPolicy',
    'ClusterGkeConfigV2MasterAuthorizedNetworksConfig',
    'ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlock',
    'ClusterGkeConfigV2NodePool',
    'ClusterGkeConfigV2NodePoolAutoscaling',
    'ClusterGkeConfigV2NodePoolConfig',
    'ClusterGkeConfigV2NodePoolConfigTaint',
    'ClusterGkeConfigV2NodePoolManagement',
    'ClusterGkeConfigV2PrivateClusterConfig',
    'ClusterK3sConfig',
    'ClusterK3sConfigUpgradeStrategy',
    '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',
    'ClusterRkeConfigNetworkAciNetworkProvider',
    'ClusterRkeConfigNetworkCalicoNetworkProvider',
    'ClusterRkeConfigNetworkCanalNetworkProvider',
    'ClusterRkeConfigNetworkFlannelNetworkProvider',
    'ClusterRkeConfigNetworkToleration',
    'ClusterRkeConfigNetworkWeaveNetworkProvider',
    'ClusterRkeConfigNode',
    'ClusterRkeConfigPrivateRegistry',
    'ClusterRkeConfigPrivateRegistryEcrCredentialPlugin',
    'ClusterRkeConfigServices',
    'ClusterRkeConfigServicesEtcd',
    'ClusterRkeConfigServicesEtcdBackupConfig',
    'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig',
    'ClusterRkeConfigServicesKubeApi',
    'ClusterRkeConfigServicesKubeApiAdmissionConfiguration',
    'ClusterRkeConfigServicesKubeApiAdmissionConfigurationPlugin',
    'ClusterRkeConfigServicesKubeApiAuditLog',
    'ClusterRkeConfigServicesKubeApiAuditLogConfiguration',
    'ClusterRkeConfigServicesKubeApiEventRateLimit',
    'ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig',
    'ClusterRkeConfigServicesKubeController',
    'ClusterRkeConfigServicesKubelet',
    'ClusterRkeConfigServicesKubeproxy',
    'ClusterRkeConfigServicesScheduler',
    'ClusterRkeConfigUpgradeStrategy',
    'ClusterRkeConfigUpgradeStrategyDrainInput',
    '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',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPlugin',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy',
    'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput',
    'ClusterTemplateTemplateRevisionQuestion',
    'ClusterV2AgentEnvVar',
    'ClusterV2ClusterAgentDeploymentCustomization',
    'ClusterV2ClusterAgentDeploymentCustomizationAppendToleration',
    'ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement',
    'ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization',
    'ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget',
    'ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass',
    'ClusterV2ClusterRegistrationToken',
    'ClusterV2FleetAgentDeploymentCustomization',
    'ClusterV2FleetAgentDeploymentCustomizationAppendToleration',
    'ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement',
    'ClusterV2LocalAuthEndpoint',
    'ClusterV2RkeConfig',
    'ClusterV2RkeConfigEtcd',
    'ClusterV2RkeConfigEtcdS3Config',
    'ClusterV2RkeConfigEtcdSnapshotCreate',
    'ClusterV2RkeConfigEtcdSnapshotRestore',
    'ClusterV2RkeConfigLocalAuthEndpoint',
    'ClusterV2RkeConfigMachinePool',
    'ClusterV2RkeConfigMachinePoolDefault',
    'ClusterV2RkeConfigMachinePoolMachineConfig',
    'ClusterV2RkeConfigMachinePoolRollingUpdate',
    'ClusterV2RkeConfigMachinePoolTaint',
    'ClusterV2RkeConfigMachineSelectorConfig',
    'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector',
    'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression',
    'ClusterV2RkeConfigMachineSelectorFile',
    'ClusterV2RkeConfigMachineSelectorFileFileSource',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItem',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceSecret',
    'ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItem',
    'ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector',
    'ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpression',
    'ClusterV2RkeConfigRegistries',
    'ClusterV2RkeConfigRegistriesConfig',
    'ClusterV2RkeConfigRegistriesMirror',
    'ClusterV2RkeConfigRotateCertificates',
    'ClusterV2RkeConfigUpgradeStrategy',
    'ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions',
    'ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions',
    'EtcdBackupBackupConfig',
    'EtcdBackupBackupConfigS3BackupConfig',
    'GlobalRoleRule',
    'MachineConfigV2Amazonec2Config',
    'MachineConfigV2AzureConfig',
    'MachineConfigV2DigitaloceanConfig',
    'MachineConfigV2HarvesterConfig',
    'MachineConfigV2LinodeConfig',
    'MachineConfigV2OpenstackConfig',
    'MachineConfigV2VsphereConfig',
    'NamespaceContainerResourceLimit',
    'NamespaceResourceQuota',
    'NamespaceResourceQuotaLimit',
    'NodePoolNodeTaint',
    'NodeTemplateAmazonec2Config',
    'NodeTemplateAzureConfig',
    'NodeTemplateDigitaloceanConfig',
    'NodeTemplateHarvesterConfig',
    'NodeTemplateHetznerConfig',
    'NodeTemplateLinodeConfig',
    'NodeTemplateNodeTaint',
    'NodeTemplateOpennebulaConfig',
    'NodeTemplateOpenstackConfig',
    'NodeTemplateOutscaleConfig',
    'NodeTemplateVsphereConfig',
    'PodSecurityAdmissionConfigurationTemplateDefaults',
    'PodSecurityAdmissionConfigurationTemplateExemptions',
    'ProjectContainerResourceLimit',
    'ProjectResourceQuota',
    'ProjectResourceQuotaNamespaceDefaultLimit',
    'ProjectResourceQuotaProjectLimit',
    'RegistryRegistry',
    'RoleTemplateExternalRule',
    'RoleTemplateRule',
    'GetClusterAksConfigResult',
    'GetClusterAksConfigV2Result',
    'GetClusterAksConfigV2NodePoolResult',
    'GetClusterClusterAuthEndpointResult',
    'GetClusterClusterRegistrationTokenResult',
    'GetClusterClusterTemplateAnswersResult',
    'GetClusterClusterTemplateQuestionResult',
    'GetClusterEksConfigResult',
    'GetClusterEksConfigV2Result',
    'GetClusterEksConfigV2NodeGroupResult',
    'GetClusterEksConfigV2NodeGroupLaunchTemplateResult',
    'GetClusterGkeConfigResult',
    'GetClusterGkeConfigV2Result',
    'GetClusterGkeConfigV2ClusterAddonsResult',
    'GetClusterGkeConfigV2IpAllocationPolicyResult',
    'GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult',
    'GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult',
    'GetClusterGkeConfigV2NodePoolResult',
    'GetClusterGkeConfigV2NodePoolAutoscalingResult',
    'GetClusterGkeConfigV2NodePoolConfigResult',
    'GetClusterGkeConfigV2NodePoolConfigTaintResult',
    'GetClusterGkeConfigV2NodePoolManagementResult',
    'GetClusterGkeConfigV2PrivateClusterConfigResult',
    'GetClusterK3sConfigResult',
    'GetClusterK3sConfigUpgradeStrategyResult',
    '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',
    'GetClusterRkeConfigNetworkAciNetworkProviderResult',
    'GetClusterRkeConfigNetworkCalicoNetworkProviderResult',
    'GetClusterRkeConfigNetworkCanalNetworkProviderResult',
    'GetClusterRkeConfigNetworkFlannelNetworkProviderResult',
    'GetClusterRkeConfigNetworkTolerationResult',
    'GetClusterRkeConfigNetworkWeaveNetworkProviderResult',
    'GetClusterRkeConfigNodeResult',
    'GetClusterRkeConfigPrivateRegistryResult',
    'GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult',
    'GetClusterRkeConfigServicesResult',
    'GetClusterRkeConfigServicesEtcdResult',
    'GetClusterRkeConfigServicesEtcdBackupConfigResult',
    'GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult',
    'GetClusterRkeConfigServicesKubeApiResult',
    'GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult',
    'GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginResult',
    'GetClusterRkeConfigServicesKubeApiAuditLogResult',
    'GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult',
    'GetClusterRkeConfigServicesKubeApiEventRateLimitResult',
    'GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult',
    'GetClusterRkeConfigServicesKubeControllerResult',
    'GetClusterRkeConfigServicesKubeletResult',
    'GetClusterRkeConfigServicesKubeproxyResult',
    'GetClusterRkeConfigServicesSchedulerResult',
    'GetClusterRkeConfigUpgradeStrategyResult',
    'GetClusterRkeConfigUpgradeStrategyDrainInputResult',
    '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',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult',
    'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult',
    'GetClusterTemplateTemplateRevisionQuestionResult',
    'GetClusterV2AgentEnvVarResult',
    'GetClusterV2ClusterRegistrationTokenResult',
    'GetClusterV2RkeConfigResult',
    'GetClusterV2RkeConfigEtcdResult',
    'GetClusterV2RkeConfigEtcdS3ConfigResult',
    'GetClusterV2RkeConfigEtcdSnapshotCreateResult',
    'GetClusterV2RkeConfigEtcdSnapshotRestoreResult',
    'GetClusterV2RkeConfigLocalAuthEndpointResult',
    'GetClusterV2RkeConfigMachinePoolResult',
    'GetClusterV2RkeConfigMachinePoolDefaultResult',
    'GetClusterV2RkeConfigMachinePoolMachineConfigResult',
    'GetClusterV2RkeConfigMachinePoolRollingUpdateResult',
    'GetClusterV2RkeConfigMachinePoolTaintResult',
    'GetClusterV2RkeConfigMachineSelectorConfigResult',
    'GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult',
    'GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult',
    'GetClusterV2RkeConfigMachineSelectorFileResult',
    'GetClusterV2RkeConfigMachineSelectorFileFileSourceResult',
    'GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapResult',
    'GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemResult',
    'GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretResult',
    'GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemResult',
    'GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorResult',
    'GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionResult',
    'GetClusterV2RkeConfigRegistriesResult',
    'GetClusterV2RkeConfigRegistriesConfigResult',
    'GetClusterV2RkeConfigRegistriesMirrorResult',
    'GetClusterV2RkeConfigRotateCertificatesResult',
    'GetClusterV2RkeConfigUpgradeStrategyResult',
    'GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult',
    'GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult',
    'GetEtcdBackupBackupConfigResult',
    'GetEtcdBackupBackupConfigS3BackupConfigResult',
    'GetGlobalRoleRuleResult',
    'GetNamespaceContainerResourceLimitResult',
    'GetNamespaceResourceQuotaResult',
    'GetNamespaceResourceQuotaLimitResult',
    'GetNodePoolNodeTaintResult',
    'GetNodeTemplateNodeTaintResult',
    'GetPodSecurityAdmissionConfigurationTemplateDefaultsResult',
    'GetPodSecurityAdmissionConfigurationTemplateExemptionsResult',
    'GetProjectContainerResourceLimitResult',
    'GetProjectResourceQuotaResult',
    'GetProjectResourceQuotaNamespaceDefaultLimitResult',
    'GetProjectResourceQuotaProjectLimitResult',
    'GetRegistryRegistryResult',
    'GetRoleTemplateExternalRuleResult',
    '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: builtins.str,
                 secret_key: builtins.str,
                 default_region: Optional[builtins.str] = None):
        """
        :param builtins.str access_key: AWS Access Key
        :param builtins.str secret_key: AWS Secret Key
        :param builtins.str default_region: AWS default region
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if default_region is not None:
            pulumi.set(__self__, "default_region", default_region)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> builtins.str:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> builtins.str:
        """
        AWS Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="defaultRegion")
    def default_region(self) -> Optional[builtins.str]:
        """
        AWS default region
        """
        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: builtins.str,
                 client_secret: builtins.str,
                 subscription_id: builtins.str,
                 environment: Optional[builtins.str] = None,
                 tenant_id: Optional[builtins.str] = None):
        """
        :param builtins.str client_id: Azure Service Principal Account ID
        :param builtins.str client_secret: Azure Service Principal Account password
        :param builtins.str subscription_id: Azure Subscription ID
        :param builtins.str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param builtins.str tenant_id: Azure Tenant ID
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

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

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

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

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

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[builtins.str]:
        """
        Azure Tenant ID
        """
        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: builtins.str):
        """
        :param builtins.str access_token: Digital Ocean access token
        """
        pulumi.set(__self__, "access_token", access_token)

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

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


@pulumi.output_type
class CloudCredentialHarvesterCredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterType":
            suggest = "cluster_type"
        elif key == "kubeconfigContent":
            suggest = "kubeconfig_content"
        elif key == "clusterId":
            suggest = "cluster_id"

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

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

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

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

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

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

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


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

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


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

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        """
        OpenStack password
        """
        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: builtins.str,
                 secret_key: builtins.str,
                 default_bucket: Optional[builtins.str] = None,
                 default_endpoint: Optional[builtins.str] = None,
                 default_endpoint_ca: Optional[builtins.str] = None,
                 default_folder: Optional[builtins.str] = None,
                 default_region: Optional[builtins.str] = None,
                 default_skip_ssl_verify: Optional[builtins.bool] = None):
        """
        :param builtins.str access_key: AWS Access Key
        :param builtins.str secret_key: AWS Secret Key
        :param builtins.str default_bucket: AWS default bucket
        :param builtins.str default_endpoint: AWS default endpoint
        :param builtins.str default_endpoint_ca: AWS default endpoint CA
        :param builtins.str default_folder: AWS default folder
        :param builtins.str default_region: AWS default region
        :param builtins.bool default_skip_ssl_verify: AWS default skip ssl verify
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if default_bucket is not None:
            pulumi.set(__self__, "default_bucket", default_bucket)
        if default_endpoint is not None:
            pulumi.set(__self__, "default_endpoint", default_endpoint)
        if default_endpoint_ca is not None:
            pulumi.set(__self__, "default_endpoint_ca", default_endpoint_ca)
        if default_folder is not None:
            pulumi.set(__self__, "default_folder", default_folder)
        if default_region is not None:
            pulumi.set(__self__, "default_region", default_region)
        if default_skip_ssl_verify is not None:
            pulumi.set(__self__, "default_skip_ssl_verify", default_skip_ssl_verify)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> builtins.str:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> builtins.str:
        """
        AWS Secret Key
        """
        return pulumi.get(self, "secret_key")

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

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

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

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

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

    @property
    @pulumi.getter(name="defaultSkipSslVerify")
    def default_skip_ssl_verify(self) -> Optional[builtins.bool]:
        """
        AWS default skip ssl verify
        """
        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: builtins.str,
                 username: builtins.str,
                 vcenter: builtins.str,
                 vcenter_port: Optional[builtins.str] = None):
        """
        :param builtins.str password: vSphere password
        :param builtins.str username: vSphere username
        :param builtins.str vcenter: vSphere IP/hostname for vCenter
        :param builtins.str vcenter_port: vSphere Port for vCenter
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        pulumi.set(__self__, "vcenter", vcenter)
        if vcenter_port is not None:
            pulumi.set(__self__, "vcenter_port", vcenter_port)

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

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

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

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


@pulumi.output_type
class ClusterAgentEnvVar(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str value: The GKE taint value (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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

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

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        Specify the version of Kubernetes
        """
        return pulumi.get(self, "kubernetes_version")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="authBaseUrl")
    def auth_base_url(self) -> Optional[builtins.str]:
        """
        Different authentication API url to use
        """
        return pulumi.get(self, "auth_base_url")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[builtins.str]:
        """
        Different resource management API url to use
        """
        return pulumi.get(self, "base_url")

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

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

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

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

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

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[builtins.str]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        return pulumi.get(self, "load_balancer_sku")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    @_utilities.deprecated("""Use tags argument instead as []string""")
    def tag(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Tags for Kubernetes cluster. For example, foo=bar
        """
        return pulumi.get(self, "tag")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[builtins.str]]:
        """
        Tags for Kubernetes cluster. For example, `["foo=bar","bar=foo"]`
        """
        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 == "nodeResourceGroup":
            suggest = "node_resource_group"
        elif key == "outboundType":
            suggest = "outbound_type"
        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: builtins.str,
                 resource_group: builtins.str,
                 resource_location: builtins.str,
                 auth_base_url: Optional[builtins.str] = None,
                 authorized_ip_ranges: Optional[Sequence[builtins.str]] = None,
                 base_url: Optional[builtins.str] = None,
                 dns_prefix: Optional[builtins.str] = None,
                 http_application_routing: Optional[builtins.bool] = None,
                 imported: Optional[builtins.bool] = None,
                 kubernetes_version: Optional[builtins.str] = None,
                 linux_admin_username: Optional[builtins.str] = None,
                 linux_ssh_public_key: Optional[builtins.str] = None,
                 load_balancer_sku: Optional[builtins.str] = None,
                 log_analytics_workspace_group: Optional[builtins.str] = None,
                 log_analytics_workspace_name: Optional[builtins.str] = None,
                 monitoring: Optional[builtins.bool] = None,
                 name: Optional[builtins.str] = None,
                 network_dns_service_ip: Optional[builtins.str] = None,
                 network_docker_bridge_cidr: Optional[builtins.str] = None,
                 network_plugin: Optional[builtins.str] = None,
                 network_pod_cidr: Optional[builtins.str] = None,
                 network_policy: Optional[builtins.str] = None,
                 network_service_cidr: Optional[builtins.str] = None,
                 node_pools: Optional[Sequence['outputs.ClusterAksConfigV2NodePool']] = None,
                 node_resource_group: Optional[builtins.str] = None,
                 outbound_type: Optional[builtins.str] = None,
                 private_cluster: Optional[builtins.bool] = None,
                 subnet: Optional[builtins.str] = None,
                 tags: Optional[Mapping[str, builtins.str]] = None,
                 virtual_network: Optional[builtins.str] = None,
                 virtual_network_resource_group: Optional[builtins.str] = None):
        """
        :param builtins.str cloud_credential_id: The AKS Cloud Credential ID to use
        :param builtins.str resource_group: The AKS resource group
        :param builtins.str resource_location: The AKS resource location
        :param builtins.str auth_base_url: The AKS auth base url
        :param Sequence[builtins.str] authorized_ip_ranges: The AKS authorized ip ranges
        :param builtins.str base_url: The AKS base url
        :param builtins.str dns_prefix: The AKS dns prefix. Required if `import=false`
        :param builtins.bool http_application_routing: Enable AKS http application routing?
        :param builtins.bool imported: Is AKS cluster imported?
        :param builtins.str kubernetes_version: The kubernetes master version. Required if `import=false`
        :param builtins.str linux_admin_username: The AKS linux admin username
        :param builtins.str linux_ssh_public_key: The AKS linux ssh public key
        :param builtins.str load_balancer_sku: The AKS load balancer sku
        :param builtins.str log_analytics_workspace_group: The AKS log analytics workspace group
        :param builtins.str log_analytics_workspace_name: The AKS log analytics workspace name
        :param builtins.bool monitoring: Is AKS cluster monitoring enabled?
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str network_dns_service_ip: The AKS network dns service ip
        :param builtins.str network_docker_bridge_cidr: The AKS network docker bridge cidr
        :param builtins.str network_plugin: The AKS network plugin. Required if `import=false`
        :param builtins.str network_pod_cidr: The AKS network pod cidr
        :param builtins.str network_policy: The AKS network policy
        :param builtins.str network_service_cidr: The AKS network service cidr
        :param Sequence['ClusterAksConfigV2NodePoolArgs'] node_pools: The AKS node pools to use. Required if `import=false`
        :param builtins.str node_resource_group: The AKS node resource group name
        :param builtins.str outbound_type: The AKS outbound type for the egress traffic
        :param builtins.bool private_cluster: Is AKS cluster private?
        :param builtins.str subnet: The AKS subnet
        :param Mapping[str, builtins.str] tags: The AKS cluster tags
        :param builtins.str virtual_network: The AKS virtual network
        :param builtins.str virtual_network_resource_group: The AKS virtual network resource group
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "resource_location", resource_location)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if authorized_ip_ranges is not None:
            pulumi.set(__self__, "authorized_ip_ranges", authorized_ip_ranges)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if dns_prefix is not None:
            pulumi.set(__self__, "dns_prefix", dns_prefix)
        if http_application_routing is not None:
            pulumi.set(__self__, "http_application_routing", http_application_routing)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if linux_admin_username is not None:
            pulumi.set(__self__, "linux_admin_username", linux_admin_username)
        if linux_ssh_public_key is not None:
            pulumi.set(__self__, "linux_ssh_public_key", linux_ssh_public_key)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if log_analytics_workspace_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_group", log_analytics_workspace_group)
        if log_analytics_workspace_name is not None:
            pulumi.set(__self__, "log_analytics_workspace_name", log_analytics_workspace_name)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_dns_service_ip is not None:
            pulumi.set(__self__, "network_dns_service_ip", network_dns_service_ip)
        if network_docker_bridge_cidr is not None:
            pulumi.set(__self__, "network_docker_bridge_cidr", network_docker_bridge_cidr)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_pod_cidr is not None:
            pulumi.set(__self__, "network_pod_cidr", network_pod_cidr)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if network_service_cidr is not None:
            pulumi.set(__self__, "network_service_cidr", network_service_cidr)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)
        if node_resource_group is not None:
            pulumi.set(__self__, "node_resource_group", node_resource_group)
        if outbound_type is not None:
            pulumi.set(__self__, "outbound_type", outbound_type)
        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) -> builtins.str:
        """
        The AKS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[builtins.str]:
        """
        The kubernetes master version. Required if `import=false`
        """
        return pulumi.get(self, "kubernetes_version")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="nodeResourceGroup")
    def node_resource_group(self) -> Optional[builtins.str]:
        """
        The AKS node resource group name
        """
        return pulumi.get(self, "node_resource_group")

    @property
    @pulumi.getter(name="outboundType")
    def outbound_type(self) -> Optional[builtins.str]:
        """
        The AKS outbound type for the egress traffic
        """
        return pulumi.get(self, "outbound_type")

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

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

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

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

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> Optional[builtins.str]:
        """
        The AKS virtual network resource group
        """
        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 == "maxSurge":
            suggest = "max_surge"
        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: builtins.str,
                 availability_zones: Optional[Sequence[builtins.str]] = None,
                 count: Optional[builtins.int] = None,
                 enable_auto_scaling: Optional[builtins.bool] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 max_count: Optional[builtins.int] = None,
                 max_pods: Optional[builtins.int] = None,
                 max_surge: Optional[builtins.str] = None,
                 min_count: Optional[builtins.int] = None,
                 mode: Optional[builtins.str] = None,
                 orchestrator_version: Optional[builtins.str] = None,
                 os_disk_size_gb: Optional[builtins.int] = None,
                 os_disk_type: Optional[builtins.str] = None,
                 os_type: Optional[builtins.str] = None,
                 taints: Optional[Sequence[builtins.str]] = None,
                 vm_size: Optional[builtins.str] = None):
        """
        :param builtins.str name: The name of the Cluster (string)
        :param Sequence[builtins.str] availability_zones: The AKS node pool availability zones
        :param builtins.int count: The AKS node pool count
        :param builtins.bool enable_auto_scaling: Is AKS node pool auto scaling enabled?
        :param Mapping[str, builtins.str] labels: Labels for the Cluster (map)
        :param builtins.int max_count: The AKS node pool max count
        :param builtins.int max_pods: The AKS node pool max pods
        :param builtins.str max_surge: The AKS node pool max surge
        :param builtins.int min_count: The AKS node pool min count
        :param builtins.str mode: The AKS node pool mode
        :param builtins.str orchestrator_version: The AKS node pool orchestrator version
        :param builtins.int os_disk_size_gb: The AKS node pool os disk size gb
        :param builtins.str os_disk_type: The AKS node pool os disk type
        :param builtins.str os_type: Enable AKS node pool os type
        :param Sequence[builtins.str] taints: The AKS node pool taints
        :param builtins.str vm_size: The AKS node pool vm size
        """
        pulumi.set(__self__, "name", name)
        if availability_zones is not None:
            pulumi.set(__self__, "availability_zones", availability_zones)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if enable_auto_scaling is not None:
            pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if max_count is not None:
            pulumi.set(__self__, "max_count", max_count)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if orchestrator_version is not None:
            pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if os_disk_type is not None:
            pulumi.set(__self__, "os_disk_type", os_disk_type)
        if os_type is not None:
            pulumi.set(__self__, "os_type", os_type)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if vm_size is not None:
            pulumi.set(__self__, "vm_size", vm_size)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class ClusterClusterAgentDeploymentCustomization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appendTolerations":
            suggest = "append_tolerations"
        elif key == "overrideAffinity":
            suggest = "override_affinity"
        elif key == "overrideResourceRequirements":
            suggest = "override_resource_requirements"
        elif key == "schedulingCustomizations":
            suggest = "scheduling_customizations"

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

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

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

    def __init__(__self__, *,
                 append_tolerations: Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationAppendToleration']] = None,
                 override_affinity: Optional[builtins.str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement']] = None,
                 scheduling_customizations: Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationSchedulingCustomization']] = None):
        """
        :param Sequence['ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param builtins.str override_affinity: User defined affinity to override default agent affinity
        :param Sequence['ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs'] override_resource_requirements: User defined resource requirements to set on the agent
        :param Sequence['ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationArgs'] scheduling_customizations: User defined scheduling customization for the cattle cluster agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)
        if scheduling_customizations is not None:
            pulumi.set(__self__, "scheduling_customizations", scheduling_customizations)

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

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

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

    @property
    @pulumi.getter(name="schedulingCustomizations")
    def scheduling_customizations(self) -> Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationSchedulingCustomization']]:
        """
        User defined scheduling customization for the cattle cluster agent
        """
        return pulumi.get(self, "scheduling_customizations")


@pulumi.output_type
class ClusterClusterAgentDeploymentCustomizationAppendToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param builtins.int seconds: The toleration seconds (int)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

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

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

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


@pulumi.output_type
class ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuLimit":
            suggest = "cpu_limit"
        elif key == "cpuRequest":
            suggest = "cpu_request"
        elif key == "memoryLimit":
            suggest = "memory_limit"
        elif key == "memoryRequest":
            suggest = "memory_request"

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

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

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

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

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

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

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

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


@pulumi.output_type
class ClusterClusterAgentDeploymentCustomizationSchedulingCustomization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podDisruptionBudgets":
            suggest = "pod_disruption_budgets"
        elif key == "priorityClasses":
            suggest = "priority_classes"

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

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

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

    def __init__(__self__, *,
                 pod_disruption_budgets: Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget']] = None,
                 priority_classes: Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass']] = None):
        """
        :param Sequence['ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudgetArgs'] pod_disruption_budgets: The Pod Disruption Budget created for the cattle cluster agent
        :param Sequence['ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClassArgs'] priority_classes: The Priority Class created for the cattle cluster agent
        """
        if pod_disruption_budgets is not None:
            pulumi.set(__self__, "pod_disruption_budgets", pod_disruption_budgets)
        if priority_classes is not None:
            pulumi.set(__self__, "priority_classes", priority_classes)

    @property
    @pulumi.getter(name="podDisruptionBudgets")
    def pod_disruption_budgets(self) -> Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget']]:
        """
        The Pod Disruption Budget created for the cattle cluster agent
        """
        return pulumi.get(self, "pod_disruption_budgets")

    @property
    @pulumi.getter(name="priorityClasses")
    def priority_classes(self) -> Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass']]:
        """
        The Priority Class created for the cattle cluster agent
        """
        return pulumi.get(self, "priority_classes")


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

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

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

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

    def __init__(__self__, *,
                 max_unavailable: Optional[builtins.str] = None,
                 min_available: Optional[builtins.str] = None):
        """
        :param builtins.str max_unavailable: The maximum number of cattle cluster agent replicas that can be down at a given time.
        :param builtins.str min_available: The minimum number of cattle cluster agent replicas that must be running at a given time.
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)
        if min_available is not None:
            pulumi.set(__self__, "min_available", min_available)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.str]:
        """
        The maximum number of cattle cluster agent replicas that can be down at a given time.
        """
        return pulumi.get(self, "max_unavailable")

    @property
    @pulumi.getter(name="minAvailable")
    def min_available(self) -> Optional[builtins.str]:
        """
        The minimum number of cattle cluster agent replicas that must be running at a given time.
        """
        return pulumi.get(self, "min_available")


@pulumi.output_type
class ClusterClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preemptionPolicy":
            suggest = "preemption_policy"

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

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

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

    def __init__(__self__, *,
                 value: builtins.int,
                 preemption_policy: Optional[builtins.str] = None):
        """
        :param builtins.int value: The priority value for the cattle cluster agent. Must be between negative 1 billion and 1 billion.
        :param builtins.str preemption_policy: The preemption behavior for the cattle cluster agent. Must be either 'PreemptLowerPriority' or 'Never'
        """
        pulumi.set(__self__, "value", value)
        if preemption_policy is not None:
            pulumi.set(__self__, "preemption_policy", preemption_policy)

    @property
    @pulumi.getter
    def value(self) -> builtins.int:
        """
        The priority value for the cattle cluster agent. Must be between negative 1 billion and 1 billion.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter(name="preemptionPolicy")
    def preemption_policy(self) -> Optional[builtins.str]:
        """
        The preemption behavior for the cattle cluster agent. Must be either 'PreemptLowerPriority' or 'Never'
        """
        return pulumi.get(self, "preemption_policy")


@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[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.str] = None):
        """
        :param builtins.str ca_certs: CA certs for the authorized cluster endpoint (string)
        :param builtins.bool enabled: Enable the authorized cluster endpoint. Default `true` (bool)
        :param builtins.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[builtins.str]:
        """
        CA certs for the authorized cluster endpoint (string)
        """
        return pulumi.get(self, "ca_certs")

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

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


@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, builtins.str]] = None,
                 cluster_id: Optional[builtins.str] = None,
                 command: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 insecure_command: Optional[builtins.str] = None,
                 insecure_node_command: Optional[builtins.str] = None,
                 insecure_windows_node_command: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 manifest_url: Optional[builtins.str] = None,
                 name: Optional[builtins.str] = None,
                 node_command: Optional[builtins.str] = None,
                 token: Optional[builtins.str] = None,
                 windows_node_command: Optional[builtins.str] = None):
        """
        :param Mapping[str, builtins.str] annotations: Annotations for the Cluster (map)
        :param builtins.str command: Command to execute in a imported k8s cluster (string)
        :param builtins.str id: (Computed) The ID of the resource (string)
        :param builtins.str insecure_command: Insecure command to execute in a imported k8s cluster (string)
        :param builtins.str insecure_node_command: Insecure node command to execute in a imported k8s cluster (string)
        :param builtins.str insecure_windows_node_command: Insecure windows command to execute in a imported k8s cluster (string)
        :param Mapping[str, builtins.str] labels: Labels for the Cluster (map)
        :param builtins.str manifest_url: K8s manifest url to execute with `kubectl` to import an existing k8s cluster (string)
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str node_command: Node command to execute in linux nodes for custom k8s cluster (string)
        :param builtins.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, builtins.str]]:
        """
        Annotations for the Cluster (map)
        """
        return pulumi.get(self, "annotations")

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

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

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

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> Optional[builtins.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[builtins.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[builtins.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, builtins.str]]:
        """
        Labels for the Cluster (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> Optional[builtins.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[builtins.str]:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> Optional[builtins.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[builtins.str] = None,
                 project_id: Optional[builtins.str] = None,
                 values: Optional[Mapping[str, builtins.str]] = None):
        """
        :param builtins.str cluster_id: Cluster ID for answer
        :param builtins.str project_id: Project ID for answer
        :param Mapping[str, builtins.str] values: Key/values for answer
        """
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if values is not None:
            pulumi.set(__self__, "values", values)

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

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

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


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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="desiredNodes")
    def desired_nodes(self) -> Optional[builtins.int]:
        """
        The desired number of worker nodes
        """
        return pulumi.get(self, "desired_nodes")

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

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

    @property
    @pulumi.getter(name="keyPairName")
    def key_pair_name(self) -> Optional[builtins.str]:
        """
        Allow user to specify key name to use
        """
        return pulumi.get(self, "key_pair_name")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence[builtins.str]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="loggingTypes")
    def logging_types(self) -> Optional[Sequence[builtins.str]]:
        """
        The AWS logging types
        """
        return pulumi.get(self, "logging_types")

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

    @property
    @pulumi.getter(name="nodeGroups")
    def node_groups(self) -> Optional[Sequence['outputs.ClusterEksConfigV2NodeGroup']]:
        """
        The AWS node groups to use
        """
        return pulumi.get(self, "node_groups")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence[builtins.str]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, builtins.str]]:
        """
        The EKS cluster tags
        """
        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 == "nodeRole":
            suggest = "node_role"
        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: builtins.str,
                 desired_size: Optional[builtins.int] = None,
                 disk_size: Optional[builtins.int] = None,
                 ec2_ssh_key: Optional[builtins.str] = None,
                 gpu: Optional[builtins.bool] = None,
                 image_id: Optional[builtins.str] = None,
                 instance_type: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 launch_templates: Optional[Sequence['outputs.ClusterEksConfigV2NodeGroupLaunchTemplate']] = None,
                 max_size: Optional[builtins.int] = None,
                 min_size: Optional[builtins.int] = None,
                 node_role: Optional[builtins.str] = None,
                 request_spot_instances: Optional[builtins.bool] = None,
                 resource_tags: Optional[Mapping[str, builtins.str]] = None,
                 spot_instance_types: Optional[Sequence[builtins.str]] = None,
                 subnets: Optional[Sequence[builtins.str]] = None,
                 tags: Optional[Mapping[str, builtins.str]] = None,
                 user_data: Optional[builtins.str] = None,
                 version: Optional[builtins.str] = None):
        """
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.int desired_size: The EKS node group desired size
        :param builtins.int disk_size: The EKS node group disk size
        :param builtins.str ec2_ssh_key: The EKS node group ssh key
        :param builtins.bool gpu: Is EKS cluster using gpu?
        :param builtins.str image_id: The EKS node group image ID
        :param builtins.str instance_type: The EKS node group instance type
        :param Mapping[str, builtins.str] labels: Labels for the Cluster (map)
        :param Sequence['ClusterEksConfigV2NodeGroupLaunchTemplateArgs'] launch_templates: The EKS node groups launch template
        :param builtins.int max_size: The EKS node group maximum size
        :param builtins.int min_size: The EKS node group minimum size
        :param builtins.str node_role: The EKS node group node role ARN
        :param builtins.bool request_spot_instances: Enable EKS node group request spot instances
        :param Mapping[str, builtins.str] resource_tags: The EKS node group resource tags
        :param Sequence[builtins.str] spot_instance_types: The EKS node group spot instance types
        :param Sequence[builtins.str] subnets: The EKS node group subnets
        :param Mapping[str, builtins.str] tags: The EKS node group tags
        :param builtins.str user_data: The EKS node group user data
        :param builtins.str version: The EKS node group k8s version
        """
        pulumi.set(__self__, "name", name)
        if desired_size is not None:
            pulumi.set(__self__, "desired_size", desired_size)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if ec2_ssh_key is not None:
            pulumi.set(__self__, "ec2_ssh_key", ec2_ssh_key)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if launch_templates is not None:
            pulumi.set(__self__, "launch_templates", launch_templates)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if node_role is not None:
            pulumi.set(__self__, "node_role", node_role)
        if request_spot_instances is not None:
            pulumi.set(__self__, "request_spot_instances", request_spot_instances)
        if resource_tags is not None:
            pulumi.set(__self__, "resource_tags", resource_tags)
        if spot_instance_types is not None:
            pulumi.set(__self__, "spot_instance_types", spot_instance_types)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Labels for the Cluster (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
        """
        return pulumi.get(self, "launch_templates")

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

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

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

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

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

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

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

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

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

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


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

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

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

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


@pulumi.output_type
class ClusterFleetAgentDeploymentCustomization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appendTolerations":
            suggest = "append_tolerations"
        elif key == "overrideAffinity":
            suggest = "override_affinity"
        elif key == "overrideResourceRequirements":
            suggest = "override_resource_requirements"

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

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

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

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

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

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

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


@pulumi.output_type
class ClusterFleetAgentDeploymentCustomizationAppendToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param builtins.int seconds: The toleration seconds (int)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

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

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

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


@pulumi.output_type
class ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuLimit":
            suggest = "cpu_limit"
        elif key == "cpuRequest":
            suggest = "cpu_request"
        elif key == "memoryLimit":
            suggest = "memory_limit"
        elif key == "memoryRequest":
            suggest = "memory_request"

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def locations(self) -> Sequence[builtins.str]:
        """
        Locations to use for the cluster
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> builtins.str:
        """
        The machine type to use for the worker nodes
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> builtins.str:
        """
        When to performance updates on the nodes, in 24-hour time
        """
        return pulumi.get(self, "maintenance_window")

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

    @property
    @pulumi.getter(name="masterVersion")
    def master_version(self) -> builtins.str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "master_version")

    @property
    @pulumi.getter
    def network(self) -> builtins.str:
        """
        The network to use for the cluster
        """
        return pulumi.get(self, "network")

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

    @property
    @pulumi.getter(name="nodeVersion")
    def node_version(self) -> builtins.str:
        """
        The version of kubernetes to use on the nodes
        """
        return pulumi.get(self, "node_version")

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        The ID of your project to use when creating a cluster
        """
        return pulumi.get(self, "project_id")

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

    @property
    @pulumi.getter(name="subNetwork")
    def sub_network(self) -> builtins.str:
        """
        The sub-network to use for the cluster
        """
        return pulumi.get(self, "sub_network")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="enableHttpLoadBalancing")
    def enable_http_load_balancing(self) -> Optional[builtins.bool]:
        """
        Enable http load balancing for the cluster
        """
        return pulumi.get(self, "enable_http_load_balancing")

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

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

    @property
    @pulumi.getter(name="enableMasterAuthorizedNetwork")
    def enable_master_authorized_network(self) -> Optional[builtins.bool]:
        """
        Whether or not master authorized network is enabled
        """
        return pulumi.get(self, "enable_master_authorized_network")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        The region to launch the cluster. Region or zone should be used
        """
        return pulumi.get(self, "region")

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

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

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

    @property
    @pulumi.getter
    def zone(self) -> Optional[builtins.str]:
        """
        The zone to launch the cluster. Zone or region should be used
        """
        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: builtins.str,
                 name: builtins.str,
                 project_id: builtins.str,
                 cluster_addons: Optional['outputs.ClusterGkeConfigV2ClusterAddons'] = None,
                 cluster_ipv4_cidr_block: Optional[builtins.str] = None,
                 description: Optional[builtins.str] = None,
                 enable_kubernetes_alpha: Optional[builtins.bool] = None,
                 imported: Optional[builtins.bool] = None,
                 ip_allocation_policy: Optional['outputs.ClusterGkeConfigV2IpAllocationPolicy'] = None,
                 kubernetes_version: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 locations: Optional[Sequence[builtins.str]] = None,
                 logging_service: Optional[builtins.str] = None,
                 maintenance_window: Optional[builtins.str] = None,
                 master_authorized_networks_config: Optional['outputs.ClusterGkeConfigV2MasterAuthorizedNetworksConfig'] = None,
                 monitoring_service: Optional[builtins.str] = None,
                 network: Optional[builtins.str] = None,
                 network_policy_enabled: Optional[builtins.bool] = None,
                 node_pools: Optional[Sequence['outputs.ClusterGkeConfigV2NodePool']] = None,
                 private_cluster_config: Optional['outputs.ClusterGkeConfigV2PrivateClusterConfig'] = None,
                 region: Optional[builtins.str] = None,
                 subnetwork: Optional[builtins.str] = None,
                 zone: Optional[builtins.str] = None):
        """
        :param builtins.str google_credential_secret: Google credential secret
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str project_id: The GKE project id
        :param 'ClusterGkeConfigV2ClusterAddonsArgs' cluster_addons: The GKE cluster addons
        :param builtins.str cluster_ipv4_cidr_block: The GKE ip v4 cidr block
        :param builtins.str description: The description for Cluster (string)
        :param builtins.bool enable_kubernetes_alpha: Enable Kubernetes alpha
        :param builtins.bool imported: Is GKE cluster imported?
        :param 'ClusterGkeConfigV2IpAllocationPolicyArgs' ip_allocation_policy: The GKE ip allocation policy
        :param builtins.str kubernetes_version: The kubernetes master version
        :param Mapping[str, builtins.str] labels: Labels for the Cluster (map)
        :param Sequence[builtins.str] locations: The GKE cluster locations
        :param builtins.str logging_service: The GKE cluster logging service
        :param builtins.str maintenance_window: The GKE cluster maintenance window
        :param 'ClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs' master_authorized_networks_config: The GKE cluster master authorized networks config
        :param builtins.str monitoring_service: The GKE cluster monitoring service
        :param builtins.str network: The GKE cluster network
        :param builtins.bool network_policy_enabled: Is GKE cluster network policy enabled?
        :param Sequence['ClusterGkeConfigV2NodePoolArgs'] node_pools: The GKE cluster node pools
        :param 'ClusterGkeConfigV2PrivateClusterConfigArgs' private_cluster_config: The GKE private cluster config
        :param builtins.str region: The GKE cluster region. Required if `zone` is empty
        :param builtins.str subnetwork: The GKE cluster subnetwork
        :param builtins.str zone: The GKE cluster zone. Required if `region` is empty
        """
        pulumi.set(__self__, "google_credential_secret", google_credential_secret)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "project_id", project_id)
        if cluster_addons is not None:
            pulumi.set(__self__, "cluster_addons", cluster_addons)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_alpha is not None:
            pulumi.set(__self__, "enable_kubernetes_alpha", enable_kubernetes_alpha)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if ip_allocation_policy is not None:
            pulumi.set(__self__, "ip_allocation_policy", ip_allocation_policy)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if logging_service is not None:
            pulumi.set(__self__, "logging_service", logging_service)
        if maintenance_window is not None:
            pulumi.set(__self__, "maintenance_window", maintenance_window)
        if master_authorized_networks_config is not None:
            pulumi.set(__self__, "master_authorized_networks_config", master_authorized_networks_config)
        if monitoring_service is not None:
            pulumi.set(__self__, "monitoring_service", monitoring_service)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if network_policy_enabled is not None:
            pulumi.set(__self__, "network_policy_enabled", network_policy_enabled)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)
        if private_cluster_config is not None:
            pulumi.set(__self__, "private_cluster_config", private_cluster_config)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

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

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        The GKE project id
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="clusterAddons")
    def cluster_addons(self) -> Optional['outputs.ClusterGkeConfigV2ClusterAddons']:
        """
        The GKE cluster addons
        """
        return pulumi.get(self, "cluster_addons")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> Optional[builtins.str]:
        """
        The GKE cluster maintenance window
        """
        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
        """
        return pulumi.get(self, "master_authorized_networks_config")

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

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

    @property
    @pulumi.getter(name="networkPolicyEnabled")
    def network_policy_enabled(self) -> Optional[builtins.bool]:
        """
        Is GKE cluster network policy enabled?
        """
        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
        """
        return pulumi.get(self, "node_pools")

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

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

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

    @property
    @pulumi.getter
    def zone(self) -> Optional[builtins.str]:
        """
        The GKE cluster zone. Required if `region` is empty
        """
        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[builtins.bool] = None,
                 http_load_balancing: Optional[builtins.bool] = None,
                 network_policy_config: Optional[builtins.bool] = None):
        """
        :param builtins.bool horizontal_pod_autoscaling: Enable GKE horizontal pod autoscaling
        :param builtins.bool http_load_balancing: Enable GKE HTTP load balancing
        :param builtins.bool network_policy_config: Enable GKE network policy config
        """
        if horizontal_pod_autoscaling is not None:
            pulumi.set(__self__, "horizontal_pod_autoscaling", horizontal_pod_autoscaling)
        if http_load_balancing is not None:
            pulumi.set(__self__, "http_load_balancing", http_load_balancing)
        if network_policy_config is not None:
            pulumi.set(__self__, "network_policy_config", network_policy_config)

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

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

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> Optional[builtins.bool]:
        """
        Enable GKE network policy config
        """
        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[builtins.str] = None,
                 cluster_secondary_range_name: Optional[builtins.str] = None,
                 create_subnetwork: Optional[builtins.bool] = None,
                 node_ipv4_cidr_block: Optional[builtins.str] = None,
                 services_ipv4_cidr_block: Optional[builtins.str] = None,
                 services_secondary_range_name: Optional[builtins.str] = None,
                 subnetwork_name: Optional[builtins.str] = None,
                 use_ip_aliases: Optional[builtins.bool] = None):
        """
        :param builtins.str cluster_ipv4_cidr_block: The GKE cluster ip v4 allocation cidr block
        :param builtins.str cluster_secondary_range_name: The GKE cluster ip v4 allocation secondary range name
        :param builtins.bool create_subnetwork: Create GKE subnetwork?
        :param builtins.str node_ipv4_cidr_block: The GKE node ip v4 allocation cidr block
        :param builtins.str services_ipv4_cidr_block: The GKE services ip v4 allocation cidr block
        :param builtins.str services_secondary_range_name: The GKE services ip v4 allocation secondary range name
        :param builtins.str subnetwork_name: The GKE cluster subnetwork name
        :param builtins.bool use_ip_aliases: Use GKE ip aliases?
        """
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, "create_subnetwork", create_subnetwork)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, "node_ipv4_cidr_block", node_ipv4_cidr_block)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        if subnetwork_name is not None:
            pulumi.set(__self__, "subnetwork_name", subnetwork_name)
        if use_ip_aliases is not None:
            pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[builtins.bool]:
        """
        Use GKE ip aliases?
        """
        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[builtins.bool] = None):
        """
        :param Sequence['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs'] cidr_blocks: The GKE master authorized network config cidr blocks
        :param builtins.bool enabled: Enable GKE master authorized network config
        """
        pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable GKE master authorized network config
        """
        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: builtins.str,
                 display_name: Optional[builtins.str] = None):
        """
        :param builtins.str cidr_block: The GKE master authorized network config cidr block
        :param builtins.str display_name: The GKE master authorized network config cidr block dispaly name
        """
        pulumi.set(__self__, "cidr_block", cidr_block)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[builtins.str]:
        """
        The GKE master authorized network config cidr block dispaly name
        """
        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: builtins.int,
                 name: builtins.str,
                 version: builtins.str,
                 autoscaling: Optional['outputs.ClusterGkeConfigV2NodePoolAutoscaling'] = None,
                 config: Optional['outputs.ClusterGkeConfigV2NodePoolConfig'] = None,
                 management: Optional['outputs.ClusterGkeConfigV2NodePoolManagement'] = None,
                 max_pods_constraint: Optional[builtins.int] = None):
        """
        :param builtins.int initial_node_count: The GKE node pool config initial node count
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str version: The GKE node pool config version
        :param 'ClusterGkeConfigV2NodePoolAutoscalingArgs' autoscaling: The GKE node pool config autoscaling
        :param 'ClusterGkeConfigV2NodePoolConfigArgs' config: The GKE node pool node config
        :param 'ClusterGkeConfigV2NodePoolManagementArgs' management: The GKE node pool config management
        :param builtins.int max_pods_constraint: The GKE node pool config max pods constraint
        """
        pulumi.set(__self__, "initial_node_count", initial_node_count)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, "max_pods_constraint", max_pods_constraint)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> Optional[builtins.int]:
        """
        The GKE node pool config max pods constraint
        """
        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[builtins.bool] = None,
                 max_node_count: Optional[builtins.int] = None,
                 min_node_count: Optional[builtins.int] = None):
        """
        :param builtins.bool enabled: Enable GKE node pool config autoscaling
        :param builtins.int max_node_count: The GKE node pool config max node count
        :param builtins.int min_node_count: The GKE node pool config min node count
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if max_node_count is not None:
            pulumi.set(__self__, "max_node_count", max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, "min_node_count", min_node_count)

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

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

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[builtins.int]:
        """
        The GKE node pool config min node count
        """
        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"
        elif key == "serviceAccount":
            suggest = "service_account"

        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[builtins.int] = None,
                 disk_type: Optional[builtins.str] = None,
                 image_type: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 local_ssd_count: Optional[builtins.int] = None,
                 machine_type: Optional[builtins.str] = None,
                 oauth_scopes: Optional[Sequence[builtins.str]] = None,
                 preemptible: Optional[builtins.bool] = None,
                 service_account: Optional[builtins.str] = None,
                 tags: Optional[Sequence[builtins.str]] = None,
                 taints: Optional[Sequence['outputs.ClusterGkeConfigV2NodePoolConfigTaint']] = None):
        """
        :param builtins.int disk_size_gb: The GKE node config disk size (Gb)
        :param builtins.str disk_type: The GKE node config disk type
        :param builtins.str image_type: The GKE node config image type
        :param Mapping[str, builtins.str] labels: Labels for the Cluster (map)
        :param builtins.int local_ssd_count: The GKE node config local ssd count
        :param builtins.str machine_type: The GKE node config machine type
        :param Sequence[builtins.str] oauth_scopes: The GKE node config oauth scopes
        :param builtins.bool preemptible: Enable GKE node config preemptible
        :param builtins.str service_account: The GKE node config service account
        :param Sequence[builtins.str] tags: The GKE node config tags
        :param Sequence['ClusterGkeConfigV2NodePoolConfigTaintArgs'] taints: The GKE node config taints
        """
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        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[builtins.int]:
        """
        The GKE node config disk size (Gb)
        """
        return pulumi.get(self, "disk_size_gb")

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

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

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

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[builtins.int]:
        """
        The GKE node config local ssd count
        """
        return pulumi.get(self, "local_ssd_count")

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

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

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

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[builtins.str]:
        """
        The GKE node config service account
        """
        return pulumi.get(self, "service_account")

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

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


@pulumi.output_type
class ClusterGkeConfigV2NodePoolConfigTaint(dict):
    def __init__(__self__, *,
                 effect: builtins.str,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str key: The GKE taint key (string)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint effect (string)
        """
        return pulumi.get(self, "effect")

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

    @property
    @pulumi.getter
    def value(self) -> builtins.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[builtins.bool] = None,
                 auto_upgrade: Optional[builtins.bool] = None):
        """
        :param builtins.bool auto_repair: Enable GKE node pool config management auto repair
        :param builtins.bool auto_upgrade: Enable GKE node pool config management auto upgrade
        """
        if auto_repair is not None:
            pulumi.set(__self__, "auto_repair", auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, "auto_upgrade", auto_upgrade)

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

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> Optional[builtins.bool]:
        """
        Enable GKE node pool config management auto upgrade
        """
        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: builtins.str,
                 enable_private_endpoint: Optional[builtins.bool] = None,
                 enable_private_nodes: Optional[builtins.bool] = None):
        """
        :param builtins.str master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block
        :param builtins.bool enable_private_endpoint: Enable GKE cluster private endpoint
        :param builtins.bool enable_private_nodes: Enable GKE cluster private nodes
        """
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)

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

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

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[builtins.bool]:
        """
        Enable GKE cluster private nodes
        """
        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[builtins.str] = None):
        """
        :param 'ClusterK3sConfigUpgradeStrategyArgs' upgrade_strategy: The K3S upgrade strategy
        :param builtins.str version: The K3S kubernetes version
        """
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

    @property
    @pulumi.getter
    def version(self) -> Optional[builtins.str]:
        """
        The K3S kubernetes version
        """
        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[builtins.bool] = None,
                 drain_worker_nodes: Optional[builtins.bool] = None,
                 server_concurrency: Optional[builtins.int] = None,
                 worker_concurrency: Optional[builtins.int] = None):
        """
        :param builtins.bool drain_server_nodes: Drain server nodes
        :param builtins.bool drain_worker_nodes: Drain worker nodes
        :param builtins.int server_concurrency: Server concurrency
        :param builtins.int worker_concurrency: Worker concurrency
        """
        if drain_server_nodes is not None:
            pulumi.set(__self__, "drain_server_nodes", drain_server_nodes)
        if drain_worker_nodes is not None:
            pulumi.set(__self__, "drain_worker_nodes", drain_worker_nodes)
        if server_concurrency is not None:
            pulumi.set(__self__, "server_concurrency", server_concurrency)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)

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

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

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

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


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

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

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

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

    @property
    @pulumi.getter(name="nodeImage")
    def node_image(self) -> builtins.str:
        """
        The OS for the node image
        """
        return pulumi.get(self, "node_image")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[builtins.bool]:
        """
        Enable the kubernetes dashboard
        """
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @property
    @pulumi.getter(name="enablePrivateControlPlane")
    def enable_private_control_plane(self) -> Optional[builtins.bool]:
        """
        Whether Kubernetes API endpoint is a private IP only accessible from within the VCN
        """
        return pulumi.get(self, "enable_private_control_plane")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[builtins.bool]:
        """
        Whether worker nodes are deployed into a new private subnet
        """
        return pulumi.get(self, "enable_private_nodes")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[builtins.str]:
        """
        Optional specify the pod CIDR, defaults to 10.244.0.0/16
        """
        return pulumi.get(self, "pod_cidr")

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

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

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

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[builtins.str]:
        """
        Optional specify the service CIDR, defaults to 10.96.0.0/16
        """
        return pulumi.get(self, "service_cidr")

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

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

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

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

    @property
    @pulumi.getter(name="workerNodeIngressCidr")
    def worker_node_ingress_cidr(self) -> Optional[builtins.str]:
        """
        Additional CIDR from which to allow ingress to worker nodes
        """
        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[builtins.str] = None):
        """
        :param 'ClusterRke2ConfigUpgradeStrategyArgs' upgrade_strategy: The RKE2 upgrade strategy
        :param builtins.str version: The RKE2 kubernetes version
        """
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

    @property
    @pulumi.getter
    def version(self) -> Optional[builtins.str]:
        """
        The RKE2 kubernetes version
        """
        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[builtins.bool] = None,
                 drain_worker_nodes: Optional[builtins.bool] = None,
                 server_concurrency: Optional[builtins.int] = None,
                 worker_concurrency: Optional[builtins.int] = None):
        """
        :param builtins.bool drain_server_nodes: Drain server nodes
        :param builtins.bool drain_worker_nodes: Drain worker nodes
        :param builtins.int server_concurrency: Server concurrency
        :param builtins.int worker_concurrency: Worker concurrency
        """
        if drain_server_nodes is not None:
            pulumi.set(__self__, "drain_server_nodes", drain_server_nodes)
        if drain_worker_nodes is not None:
            pulumi.set(__self__, "drain_worker_nodes", drain_worker_nodes)
        if server_concurrency is not None:
            pulumi.set(__self__, "server_concurrency", server_concurrency)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)

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

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

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

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[builtins.int]:
        """
        Worker concurrency
        """
        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[builtins.int] = None,
                 addons: Optional[builtins.str] = None,
                 addons_includes: Optional[Sequence[builtins.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[builtins.bool] = None,
                 ignore_docker_version: Optional[builtins.bool] = None,
                 ingress: Optional['outputs.ClusterRkeConfigIngress'] = None,
                 kubernetes_version: Optional[builtins.str] = None,
                 monitoring: Optional['outputs.ClusterRkeConfigMonitoring'] = None,
                 network: Optional['outputs.ClusterRkeConfigNetwork'] = None,
                 nodes: Optional[Sequence['outputs.ClusterRkeConfigNode']] = None,
                 prefix_path: Optional[builtins.str] = None,
                 private_registries: Optional[Sequence['outputs.ClusterRkeConfigPrivateRegistry']] = None,
                 services: Optional['outputs.ClusterRkeConfigServices'] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None,
                 ssh_cert_path: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.str] = None,
                 upgrade_strategy: Optional['outputs.ClusterRkeConfigUpgradeStrategy'] = None,
                 win_prefix_path: Optional[builtins.str] = None):
        """
        :param builtins.int addon_job_timeout: Optional duration in seconds of addon job.
        :param builtins.str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[builtins.str] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param 'ClusterRkeConfigAuthenticationArgs' authentication: Kubernetes cluster authentication
        :param 'ClusterRkeConfigAuthorizationArgs' authorization: Kubernetes cluster authorization
        :param 'ClusterRkeConfigBastionHostArgs' bastion_host: RKE bastion host
        :param 'ClusterRkeConfigCloudProviderArgs' cloud_provider: RKE options for Calico network provider (string)
        :param 'ClusterRkeConfigDnsArgs' dns: RKE dns add-on. For Rancher v2.2.x (list maxitems:1)
        :param builtins.bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param builtins.bool ignore_docker_version: Optional ignore docker version on nodes
        :param 'ClusterRkeConfigIngressArgs' ingress: Kubernetes ingress configuration
        :param builtins.str kubernetes_version: Optional kubernetes version to deploy
        :param 'ClusterRkeConfigMonitoringArgs' monitoring: Kubernetes cluster monitoring
        :param 'ClusterRkeConfigNetworkArgs' network: Kubernetes cluster networking
        :param Sequence['ClusterRkeConfigNodeArgs'] nodes: Optional RKE cluster nodes
        :param builtins.str prefix_path: Optional prefix to customize kubernetes path
        :param Sequence['ClusterRkeConfigPrivateRegistryArgs'] private_registries: Optional private registries for docker images
        :param 'ClusterRkeConfigServicesArgs' services: Kubernetes cluster services
        :param builtins.bool ssh_agent_auth: Optional use ssh agent auth
        :param builtins.str ssh_cert_path: Optional cluster level SSH certificate path
        :param builtins.str ssh_key_path: Optional cluster level SSH private key path
        :param 'ClusterRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param builtins.str win_prefix_path: Optional prefix to customize kubernetes path for windows
        """
        if addon_job_timeout is not None:
            pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if bastion_host is not None:
            pulumi.set(__self__, "bastion_host", bastion_host)
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if win_prefix_path is not None:
            pulumi.set(__self__, "win_prefix_path", win_prefix_path)

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

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

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[Sequence[builtins.str]]:
        """
        Optional addons yaml manisfest to deploy on rke cluster.
        """
        return pulumi.get(self, "addons_includes")

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

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

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> Optional['outputs.ClusterRkeConfigBastionHost']:
        """
        RKE bastion host
        """
        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. For Rancher v2.2.x (list maxitems:1)
        """
        return pulumi.get(self, "dns")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

    @property
    @pulumi.getter
    def options(self) -> Optional[Mapping[str, builtins.str]]:
        """
        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: builtins.str,
                 user: builtins.str,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None,
                 ssh_key: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.str] = None):
        """
        :param builtins.str address: Address ip for node (string)
        :param builtins.str user: Registry user (string)
        :param builtins.str port: Port for node. Default `22` (string)
        :param builtins.bool ssh_agent_auth: Use ssh agent auth. Default `false` (bool)
        :param builtins.str ssh_key: Node SSH private key (string)
        :param builtins.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) -> builtins.str:
        """
        Address ip for node (string)
        """
        return pulumi.get(self, "address")

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

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

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.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[builtins.str]:
        """
        Node SSH private key (string)
        """
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[builtins.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[builtins.str] = None,
                 name: Optional[builtins.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 builtins.str custom_cloud_provider: RKE Custom Cloud Provider config for Cloud Provider (string)
        :param builtins.str name: The name of the Cluster (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[builtins.str]:
        """
        RKE Custom Cloud Provider config for Cloud Provider (string)
        """
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        The name of the Cluster (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[builtins.bool] = None,
                 disable_strict_zone_check: Optional[builtins.bool] = None,
                 elb_security_group: Optional[builtins.str] = None,
                 kubernetes_cluster_id: Optional[builtins.str] = None,
                 kubernetes_cluster_tag: Optional[builtins.str] = None,
                 role_arn: Optional[builtins.str] = None,
                 route_table_id: Optional[builtins.str] = None,
                 subnet_id: Optional[builtins.str] = None,
                 vpc: Optional[builtins.str] = None,
                 zone: Optional[builtins.str] = None):
        """
        :param builtins.bool disable_security_group_ingress: Default `false` (bool)
        :param builtins.bool disable_strict_zone_check: Default `false` (bool)
        :param builtins.str elb_security_group: (string)
        :param builtins.str kubernetes_cluster_id: (string)
        :param builtins.str kubernetes_cluster_tag: (string)
        :param builtins.str role_arn: (string)
        :param builtins.str route_table_id: (string)
        :param builtins.str subnet_id: (string)
        :param builtins.str vpc: (string)
        :param builtins.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[builtins.bool]:
        """
        Default `false` (bool)
        """
        return pulumi.get(self, "disable_security_group_ingress")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def zone(self) -> Optional[builtins.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: builtins.str,
                 region: Optional[builtins.str] = None,
                 signing_method: Optional[builtins.str] = None,
                 signing_name: Optional[builtins.str] = None,
                 signing_region: Optional[builtins.str] = None,
                 url: Optional[builtins.str] = None):
        """
        :param builtins.str service: (string)
        :param builtins.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 builtins.str signing_method: (string)
        :param builtins.str signing_name: (string)
        :param builtins.str signing_region: (string)
        :param builtins.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) -> builtins.str:
        """
        (string)
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.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[builtins.str]:
        """
        (string)
        """
        return pulumi.get(self, "signing_method")

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

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

    @property
    @pulumi.getter
    def url(self) -> Optional[builtins.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: builtins.str,
                 aad_client_secret: builtins.str,
                 subscription_id: builtins.str,
                 tenant_id: builtins.str,
                 aad_client_cert_password: Optional[builtins.str] = None,
                 aad_client_cert_path: Optional[builtins.str] = None,
                 cloud: Optional[builtins.str] = None,
                 cloud_provider_backoff: Optional[builtins.bool] = None,
                 cloud_provider_backoff_duration: Optional[builtins.int] = None,
                 cloud_provider_backoff_exponent: Optional[builtins.int] = None,
                 cloud_provider_backoff_jitter: Optional[builtins.int] = None,
                 cloud_provider_backoff_retries: Optional[builtins.int] = None,
                 cloud_provider_rate_limit: Optional[builtins.bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[builtins.int] = None,
                 cloud_provider_rate_limit_qps: Optional[builtins.int] = None,
                 load_balancer_sku: Optional[builtins.str] = None,
                 location: Optional[builtins.str] = None,
                 maximum_load_balancer_rule_count: Optional[builtins.int] = None,
                 primary_availability_set_name: Optional[builtins.str] = None,
                 primary_scale_set_name: Optional[builtins.str] = None,
                 resource_group: Optional[builtins.str] = None,
                 route_table_name: Optional[builtins.str] = None,
                 security_group_name: Optional[builtins.str] = None,
                 subnet_name: Optional[builtins.str] = None,
                 use_instance_metadata: Optional[builtins.bool] = None,
                 use_managed_identity_extension: Optional[builtins.bool] = None,
                 vm_type: Optional[builtins.str] = None,
                 vnet_name: Optional[builtins.str] = None,
                 vnet_resource_group: Optional[builtins.str] = None):
        """
        :param builtins.str aad_client_id: (string)
        :param builtins.str aad_client_secret: (string)
        :param builtins.str subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription (string)
        :param builtins.str tenant_id: Azure tenant ID to use (string)
        :param builtins.str aad_client_cert_password: (string)
        :param builtins.str aad_client_cert_path: (string)
        :param builtins.str cloud: (string)
        :param builtins.bool cloud_provider_backoff: (bool)
        :param builtins.int cloud_provider_backoff_duration: (int)
        :param builtins.int cloud_provider_backoff_exponent: (int)
        :param builtins.int cloud_provider_backoff_jitter: (int)
        :param builtins.int cloud_provider_backoff_retries: (int)
        :param builtins.bool cloud_provider_rate_limit: (bool)
        :param builtins.int cloud_provider_rate_limit_bucket: (int)
        :param builtins.int cloud_provider_rate_limit_qps: (int)
        :param builtins.str load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        :param builtins.str location: Azure Kubernetes cluster location. Default `eastus` (string)
        :param builtins.int maximum_load_balancer_rule_count: (int)
        :param builtins.str primary_availability_set_name: (string)
        :param builtins.str primary_scale_set_name: (string)
        :param builtins.str resource_group: The AKS resource group (string)
        :param builtins.str route_table_name: (string)
        :param builtins.str security_group_name: (string)
        :param builtins.str subnet_name: (string)
        :param builtins.bool use_instance_metadata: (bool)
        :param builtins.bool use_managed_identity_extension: (bool)
        :param builtins.str vm_type: (string)
        :param builtins.str vnet_name: (string)
        :param builtins.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) -> builtins.str:
        """
        (string)
        """
        return pulumi.get(self, "aad_client_id")

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

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> builtins.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) -> builtins.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[builtins.str]:
        """
        (string)
        """
        return pulumi.get(self, "aad_client_cert_password")

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[builtins.str]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        return pulumi.get(self, "load_balancer_sku")

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> Optional[builtins.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[builtins.str] = None,
                 ignore_volume_az: Optional[builtins.bool] = None,
                 trust_device_path: Optional[builtins.bool] = None):
        """
        :param builtins.str bs_version: (string)
        :param builtins.bool ignore_volume_az: (string)
        :param builtins.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[builtins.str]:
        """
        (string)
        """
        return pulumi.get(self, "bs_version")

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

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> Optional[builtins.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: builtins.str,
                 password: builtins.str,
                 username: builtins.str,
                 ca_file: Optional[builtins.str] = None,
                 domain_id: Optional[builtins.str] = None,
                 domain_name: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 tenant_id: Optional[builtins.str] = None,
                 tenant_name: Optional[builtins.str] = None,
                 trust_id: Optional[builtins.str] = None):
        """
        :param builtins.str auth_url: (string)
        :param builtins.str password: Registry password (string)
        :param builtins.str username: (string)
        :param builtins.str ca_file: (string)
        :param builtins.str domain_id: Required if `domain_name` not provided. (string)
        :param builtins.str domain_name: Required if `domain_id` not provided. (string)
        :param builtins.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 builtins.str tenant_id: Azure tenant ID to use (string)
        :param builtins.str tenant_name: Required if `tenant_id` not provided. (string)
        :param builtins.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) -> builtins.str:
        """
        (string)
        """
        return pulumi.get(self, "auth_url")

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

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

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

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

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

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.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[builtins.str]:
        """
        Azure tenant ID to use (string)
        """
        return pulumi.get(self, "tenant_id")

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

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> Optional[builtins.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[builtins.bool] = None,
                 floating_network_id: Optional[builtins.str] = None,
                 lb_method: Optional[builtins.str] = None,
                 lb_provider: Optional[builtins.str] = None,
                 lb_version: Optional[builtins.str] = None,
                 manage_security_groups: Optional[builtins.bool] = None,
                 monitor_delay: Optional[builtins.str] = None,
                 monitor_max_retries: Optional[builtins.int] = None,
                 monitor_timeout: Optional[builtins.str] = None,
                 subnet_id: Optional[builtins.str] = None,
                 use_octavia: Optional[builtins.bool] = None):
        """
        :param builtins.bool create_monitor: (bool)
        :param builtins.str floating_network_id: (string)
        :param builtins.str lb_method: (string)
        :param builtins.str lb_provider: (string)
        :param builtins.str lb_version: (string)
        :param builtins.bool manage_security_groups: (bool)
        :param builtins.str monitor_delay: Default `60s` (string)
        :param builtins.int monitor_max_retries: Default 5 (int)
        :param builtins.str monitor_timeout: Default `30s` (string)
        :param builtins.str subnet_id: (string)
        :param builtins.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[builtins.bool]:
        """
        (bool)
        """
        return pulumi.get(self, "create_monitor")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> Optional[builtins.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[builtins.int] = None,
                 search_order: Optional[builtins.str] = None):
        """
        :param builtins.int request_timeout: (int)
        :param builtins.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[builtins.int]:
        """
        (int)
        """
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param builtins.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[builtins.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[builtins.str] = None):
        """
        :param builtins.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[builtins.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 == "gracefulShutdownTimeout":
            suggest = "graceful_shutdown_timeout"
        elif 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[builtins.str] = None,
                 graceful_shutdown_timeout: Optional[builtins.str] = None,
                 insecure_flag: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 soap_roundtrip_count: Optional[builtins.int] = None,
                 user: Optional[builtins.str] = None):
        """
        :param builtins.str datacenters: (string)
        :param builtins.bool insecure_flag: (bool)
        :param builtins.str password: Registry password (string)
        :param builtins.str port: Port for node. Default `22` (string)
        :param builtins.int soap_roundtrip_count: (int)
        :param builtins.str user: Registry user (string)
        """
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        if insecure_flag is not None:
            pulumi.set(__self__, "insecure_flag", insecure_flag)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

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

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

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

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

    @property
    @pulumi.getter
    def user(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param builtins.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[builtins.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: builtins.str,
                 name: builtins.str,
                 password: builtins.str,
                 user: builtins.str,
                 port: Optional[builtins.str] = None,
                 soap_roundtrip_count: Optional[builtins.int] = None):
        """
        :param builtins.str datacenters: (string)
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str password: Registry password (string)
        :param builtins.str user: Registry user (string)
        :param builtins.str port: Port for node. Default `22` (string)
        :param builtins.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) -> builtins.str:
        """
        (string)
        """
        return pulumi.get(self, "datacenters")

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

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

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

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

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[builtins.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: builtins.str,
                 folder: builtins.str,
                 server: builtins.str,
                 default_datastore: Optional[builtins.str] = None,
                 resourcepool_path: Optional[builtins.str] = None):
        """
        :param builtins.str datacenter: (string)
        :param builtins.str folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param builtins.str server: (string)
        :param builtins.str default_datastore: (string)
        :param builtins.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) -> builtins.str:
        """
        (string)
        """
        return pulumi.get(self, "datacenter")

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

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

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

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> Optional[builtins.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, builtins.str]] = None,
                 nodelocal: Optional['outputs.ClusterRkeConfigDnsNodelocal'] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 provider: Optional[builtins.str] = None,
                 reverse_cidrs: Optional[Sequence[builtins.str]] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigDnsToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigDnsUpdateStrategy'] = None,
                 upstream_nameservers: Optional[Sequence[builtins.str]] = None):
        """
        :param 'ClusterRkeConfigDnsLinearAutoscalerParamsArgs' linear_autoscaler_params: Linear Autoscaler Params
        :param Mapping[str, builtins.str] node_selector: RKE monitoring node selector (map)
        :param 'ClusterRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns
        :param Mapping[str, builtins.str] options: RKE options for network (map)
        :param builtins.str provider: RKE monitoring provider (string)
        :param Sequence[builtins.str] reverse_cidrs: DNS add-on reverse cidr  (list)
        :param Sequence['ClusterRkeConfigDnsTolerationArgs'] tolerations: DNS service tolerations
        :param 'ClusterRkeConfigDnsUpdateStrategyArgs' update_strategy: Update deployment strategy
        :param Sequence[builtins.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']:
        """
        Linear Autoscaler Params
        """
        return pulumi.get(self, "linear_autoscaler_params")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Optional[Sequence[builtins.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[builtins.float] = None,
                 max: Optional[builtins.int] = None,
                 min: Optional[builtins.int] = None,
                 nodes_per_replica: Optional[builtins.float] = None,
                 prevent_single_point_failure: Optional[builtins.bool] = None):
        """
        :param builtins.float cores_per_replica: number of replicas per cluster cores (float64)
        :param builtins.int max: maximum number of replicas (int64)
        :param builtins.int min: minimum number of replicas (int64)
        :param builtins.float nodes_per_replica: number of replica per cluster nodes (float64)
        :param builtins.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[builtins.float]:
        """
        number of replicas per cluster cores (float64)
        """
        return pulumi.get(self, "cores_per_replica")

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

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

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[builtins.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[builtins.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[builtins.str] = None,
                 node_selector: Optional[Mapping[str, builtins.str]] = None):
        """
        :param builtins.str ip_address: Nodelocal dns ip address (string)
        :param Mapping[str, builtins.str] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

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

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class ClusterRkeConfigDnsToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param builtins.int seconds: The toleration seconds (int)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param 'ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterRkeConfigDnsUpdateStrategyRollingUpdate']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        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[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        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[builtins.bool] = None,
                 dns_policy: Optional[builtins.str] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 http_port: Optional[builtins.int] = None,
                 https_port: Optional[builtins.int] = None,
                 network_mode: Optional[builtins.str] = None,
                 node_selector: Optional[Mapping[str, builtins.str]] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 provider: Optional[builtins.str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigIngressToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigIngressUpdateStrategy'] = None):
        """
        :param builtins.bool default_backend: Enable ingress default backend. Default: `true` (bool)
        :param builtins.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, builtins.str] extra_args: Extra arguments for scheduler service (map)
        :param builtins.int http_port: HTTP port for RKE Ingress (int)
        :param builtins.int https_port: HTTPS port for RKE Ingress (int)
        :param builtins.str network_mode: Network mode for RKE Ingress (string)
        :param Mapping[str, builtins.str] node_selector: RKE monitoring node selector (map)
        :param Mapping[str, builtins.str] options: RKE options for network (map)
        :param builtins.str provider: RKE monitoring provider (string)
        :param Sequence['ClusterRkeConfigIngressTolerationArgs'] tolerations: Ingress add-on tolerations
        :param 'ClusterRkeConfigIngressUpdateStrategyArgs' update_strategy: Update daemon set strategy
        """
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if http_port is not None:
            pulumi.set(__self__, "http_port", http_port)
        if https_port is not None:
            pulumi.set(__self__, "https_port", https_port)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

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

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> Optional[builtins.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, builtins.str]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> Optional[builtins.int]:
        """
        HTTP port for RKE Ingress (int)
        """
        return pulumi.get(self, "http_port")

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

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> Optional[builtins.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, builtins.str]]:
        """
        RKE monitoring node selector (map)
        """
        return pulumi.get(self, "node_selector")

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

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

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

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


@pulumi.output_type
class ClusterRkeConfigIngressToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param builtins.int seconds: The toleration seconds (int)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param 'ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterRkeConfigIngressUpdateStrategyRollingUpdate']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        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[builtins.int] = None):
        """
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        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, builtins.str]] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 provider: Optional[builtins.str] = None,
                 replicas: Optional[builtins.int] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigMonitoringToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategy'] = None):
        """
        :param Mapping[str, builtins.str] node_selector: RKE monitoring node selector (map)
        :param Mapping[str, builtins.str] options: RKE options for network (map)
        :param builtins.str provider: RKE monitoring provider (string)
        :param builtins.int replicas: RKE monitoring replicas (int)
        :param Sequence['ClusterRkeConfigMonitoringTolerationArgs'] tolerations: Monitoring add-on tolerations
        :param 'ClusterRkeConfigMonitoringUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

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

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

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

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

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

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


@pulumi.output_type
class ClusterRkeConfigMonitoringToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param builtins.int seconds: The toleration seconds (int)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param 'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        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[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

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


@pulumi.output_type
class ClusterRkeConfigNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aciNetworkProvider":
            suggest = "aci_network_provider"
        elif 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__, *,
                 aci_network_provider: Optional['outputs.ClusterRkeConfigNetworkAciNetworkProvider'] = None,
                 calico_network_provider: Optional['outputs.ClusterRkeConfigNetworkCalicoNetworkProvider'] = None,
                 canal_network_provider: Optional['outputs.ClusterRkeConfigNetworkCanalNetworkProvider'] = None,
                 flannel_network_provider: Optional['outputs.ClusterRkeConfigNetworkFlannelNetworkProvider'] = None,
                 mtu: Optional[builtins.int] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 plugin: Optional[builtins.str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigNetworkToleration']] = None,
                 weave_network_provider: Optional['outputs.ClusterRkeConfigNetworkWeaveNetworkProvider'] = None):
        """
        :param 'ClusterRkeConfigNetworkAciNetworkProviderArgs' aci_network_provider: ACI provider config for RKE network (list maxitems:63)
        :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 builtins.int mtu: Network provider MTU. Default `0` (int)
        :param Mapping[str, builtins.str] options: RKE options for network (map)
        :param builtins.str plugin: Plugin for RKE network. `canal` (default), `flannel`, `calico`, `none` and `weave` are supported. (string)
        :param Sequence['ClusterRkeConfigNetworkTolerationArgs'] tolerations: Network add-on tolerations
        :param 'ClusterRkeConfigNetworkWeaveNetworkProviderArgs' weave_network_provider: Weave provider config for RKE network (list maxitems:1)
        """
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="aciNetworkProvider")
    def aci_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkAciNetworkProvider']:
        """
        ACI provider config for RKE network (list maxitems:63)
        """
        return pulumi.get(self, "aci_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[builtins.int]:
        """
        Network provider MTU. Default `0` (int)
        """
        return pulumi.get(self, "mtu")

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

    @property
    @pulumi.getter
    def plugin(self) -> Optional[builtins.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
        """
        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 ClusterRkeConfigNetworkAciNetworkProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apicHosts":
            suggest = "apic_hosts"
        elif key == "apicUserCrt":
            suggest = "apic_user_crt"
        elif key == "apicUserKey":
            suggest = "apic_user_key"
        elif key == "apicUserName":
            suggest = "apic_user_name"
        elif key == "encapType":
            suggest = "encap_type"
        elif key == "externDynamic":
            suggest = "extern_dynamic"
        elif key == "externStatic":
            suggest = "extern_static"
        elif key == "kubeApiVlan":
            suggest = "kube_api_vlan"
        elif key == "l3outExternalNetworks":
            suggest = "l3out_external_networks"
        elif key == "mcastRangeEnd":
            suggest = "mcast_range_end"
        elif key == "mcastRangeStart":
            suggest = "mcast_range_start"
        elif key == "nodeSubnet":
            suggest = "node_subnet"
        elif key == "nodeSvcSubnet":
            suggest = "node_svc_subnet"
        elif key == "serviceVlan":
            suggest = "service_vlan"
        elif key == "systemId":
            suggest = "system_id"
        elif key == "vrfName":
            suggest = "vrf_name"
        elif key == "vrfTenant":
            suggest = "vrf_tenant"
        elif key == "apicRefreshTickerAdjust":
            suggest = "apic_refresh_ticker_adjust"
        elif key == "apicRefreshTime":
            suggest = "apic_refresh_time"
        elif key == "apicSubscriptionDelay":
            suggest = "apic_subscription_delay"
        elif key == "controllerLogLevel":
            suggest = "controller_log_level"
        elif key == "disablePeriodicSnatGlobalInfoSync":
            suggest = "disable_periodic_snat_global_info_sync"
        elif key == "disableWaitForNetwork":
            suggest = "disable_wait_for_network"
        elif key == "dropLogEnable":
            suggest = "drop_log_enable"
        elif key == "durationWaitForNetwork":
            suggest = "duration_wait_for_network"
        elif key == "enableEndpointSlice":
            suggest = "enable_endpoint_slice"
        elif key == "epRegistry":
            suggest = "ep_registry"
        elif key == "gbpPodSubnet":
            suggest = "gbp_pod_subnet"
        elif key == "hostAgentLogLevel":
            suggest = "host_agent_log_level"
        elif key == "imagePullPolicy":
            suggest = "image_pull_policy"
        elif key == "imagePullSecret":
            suggest = "image_pull_secret"
        elif key == "infraVlan":
            suggest = "infra_vlan"
        elif key == "installIstio":
            suggest = "install_istio"
        elif key == "istioProfile":
            suggest = "istio_profile"
        elif key == "kafkaBrokers":
            suggest = "kafka_brokers"
        elif key == "kafkaClientCrt":
            suggest = "kafka_client_crt"
        elif key == "kafkaClientKey":
            suggest = "kafka_client_key"
        elif key == "maxNodesSvcGraph":
            suggest = "max_nodes_svc_graph"
        elif key == "mtuHeadRoom":
            suggest = "mtu_head_room"
        elif key == "multusDisable":
            suggest = "multus_disable"
        elif key == "noPriorityClass":
            suggest = "no_priority_class"
        elif key == "nodePodIfEnable":
            suggest = "node_pod_if_enable"
        elif key == "opflexClientSsl":
            suggest = "opflex_client_ssl"
        elif key == "opflexDeviceDeleteTimeout":
            suggest = "opflex_device_delete_timeout"
        elif key == "opflexLogLevel":
            suggest = "opflex_log_level"
        elif key == "opflexMode":
            suggest = "opflex_mode"
        elif key == "opflexServerPort":
            suggest = "opflex_server_port"
        elif key == "overlayVrfName":
            suggest = "overlay_vrf_name"
        elif key == "ovsMemoryLimit":
            suggest = "ovs_memory_limit"
        elif key == "pbrTrackingNonSnat":
            suggest = "pbr_tracking_non_snat"
        elif key == "podSubnetChunkSize":
            suggest = "pod_subnet_chunk_size"
        elif key == "runGbpContainer":
            suggest = "run_gbp_container"
        elif key == "runOpflexServerContainer":
            suggest = "run_opflex_server_container"
        elif key == "serviceMonitorInterval":
            suggest = "service_monitor_interval"
        elif key == "snatContractScope":
            suggest = "snat_contract_scope"
        elif key == "snatNamespace":
            suggest = "snat_namespace"
        elif key == "snatPortRangeEnd":
            suggest = "snat_port_range_end"
        elif key == "snatPortRangeStart":
            suggest = "snat_port_range_start"
        elif key == "snatPortsPerNode":
            suggest = "snat_ports_per_node"
        elif key == "sriovEnable":
            suggest = "sriov_enable"
        elif key == "subnetDomainName":
            suggest = "subnet_domain_name"
        elif key == "useAciAnywhereCrd":
            suggest = "use_aci_anywhere_crd"
        elif key == "useAciCniPriorityClass":
            suggest = "use_aci_cni_priority_class"
        elif key == "useClusterRole":
            suggest = "use_cluster_role"
        elif key == "useHostNetnsVolume":
            suggest = "use_host_netns_volume"
        elif key == "useOpflexServerVolume":
            suggest = "use_opflex_server_volume"
        elif key == "usePrivilegedContainer":
            suggest = "use_privileged_container"
        elif key == "vmmController":
            suggest = "vmm_controller"
        elif key == "vmmDomain":
            suggest = "vmm_domain"

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

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

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

    def __init__(__self__, *,
                 aep: builtins.str,
                 apic_hosts: Sequence[builtins.str],
                 apic_user_crt: builtins.str,
                 apic_user_key: builtins.str,
                 apic_user_name: builtins.str,
                 encap_type: builtins.str,
                 extern_dynamic: builtins.str,
                 extern_static: builtins.str,
                 kube_api_vlan: builtins.str,
                 l3out: builtins.str,
                 l3out_external_networks: Sequence[builtins.str],
                 mcast_range_end: builtins.str,
                 mcast_range_start: builtins.str,
                 node_subnet: builtins.str,
                 node_svc_subnet: builtins.str,
                 service_vlan: builtins.str,
                 system_id: builtins.str,
                 token: builtins.str,
                 vrf_name: builtins.str,
                 vrf_tenant: builtins.str,
                 apic_refresh_ticker_adjust: Optional[builtins.str] = None,
                 apic_refresh_time: Optional[builtins.str] = None,
                 apic_subscription_delay: Optional[builtins.str] = None,
                 capic: Optional[builtins.str] = None,
                 controller_log_level: Optional[builtins.str] = None,
                 disable_periodic_snat_global_info_sync: Optional[builtins.str] = None,
                 disable_wait_for_network: Optional[builtins.str] = None,
                 drop_log_enable: Optional[builtins.str] = None,
                 duration_wait_for_network: Optional[builtins.str] = None,
                 enable_endpoint_slice: Optional[builtins.str] = None,
                 ep_registry: Optional[builtins.str] = None,
                 gbp_pod_subnet: Optional[builtins.str] = None,
                 host_agent_log_level: Optional[builtins.str] = None,
                 image_pull_policy: Optional[builtins.str] = None,
                 image_pull_secret: Optional[builtins.str] = None,
                 infra_vlan: Optional[builtins.str] = None,
                 install_istio: Optional[builtins.str] = None,
                 istio_profile: Optional[builtins.str] = None,
                 kafka_brokers: Optional[Sequence[builtins.str]] = None,
                 kafka_client_crt: Optional[builtins.str] = None,
                 kafka_client_key: Optional[builtins.str] = None,
                 max_nodes_svc_graph: Optional[builtins.str] = None,
                 mtu_head_room: Optional[builtins.str] = None,
                 multus_disable: Optional[builtins.str] = None,
                 no_priority_class: Optional[builtins.str] = None,
                 node_pod_if_enable: Optional[builtins.str] = None,
                 opflex_client_ssl: Optional[builtins.str] = None,
                 opflex_device_delete_timeout: Optional[builtins.str] = None,
                 opflex_log_level: Optional[builtins.str] = None,
                 opflex_mode: Optional[builtins.str] = None,
                 opflex_server_port: Optional[builtins.str] = None,
                 overlay_vrf_name: Optional[builtins.str] = None,
                 ovs_memory_limit: Optional[builtins.str] = None,
                 pbr_tracking_non_snat: Optional[builtins.str] = None,
                 pod_subnet_chunk_size: Optional[builtins.str] = None,
                 run_gbp_container: Optional[builtins.str] = None,
                 run_opflex_server_container: Optional[builtins.str] = None,
                 service_monitor_interval: Optional[builtins.str] = None,
                 snat_contract_scope: Optional[builtins.str] = None,
                 snat_namespace: Optional[builtins.str] = None,
                 snat_port_range_end: Optional[builtins.str] = None,
                 snat_port_range_start: Optional[builtins.str] = None,
                 snat_ports_per_node: Optional[builtins.str] = None,
                 sriov_enable: Optional[builtins.str] = None,
                 subnet_domain_name: Optional[builtins.str] = None,
                 tenant: Optional[builtins.str] = None,
                 use_aci_anywhere_crd: Optional[builtins.str] = None,
                 use_aci_cni_priority_class: Optional[builtins.str] = None,
                 use_cluster_role: Optional[builtins.str] = None,
                 use_host_netns_volume: Optional[builtins.str] = None,
                 use_opflex_server_volume: Optional[builtins.str] = None,
                 use_privileged_container: Optional[builtins.str] = None,
                 vmm_controller: Optional[builtins.str] = None,
                 vmm_domain: Optional[builtins.str] = None):
        """
        :param builtins.str aep: Attachable entity profile (string)
        :param Sequence[builtins.str] apic_hosts: List of APIC hosts to connect for APIC API (list)
        :param builtins.str apic_user_crt: APIC user certificate (string)
        :param builtins.str apic_user_key: APIC user key (string)
        :param builtins.str apic_user_name: APIC user name (string)
        :param builtins.str encap_type: Encap type: vxlan or vlan (string)
        :param builtins.str extern_dynamic: Subnet to use for dynamic external IPs (string)
        :param builtins.str extern_static: Subnet to use for static external IPs (string)
        :param builtins.str kube_api_vlan: The VLAN used by the physdom for nodes (string)
        :param builtins.str l3out: L3out (string)
        :param Sequence[builtins.str] l3out_external_networks: L3out external networks (list)
        :param builtins.str mcast_range_end: End of mcast range (string)
        :param builtins.str mcast_range_start: Start of mcast range (string)
        :param builtins.str node_subnet: Subnet to use for nodes (string)
        :param builtins.str node_svc_subnet: Subnet to use for service graph (string)
        :param builtins.str service_vlan: The VLAN used by LoadBalancer services (string)
        :param builtins.str system_id: ACI system ID (string)
        :param builtins.str vrf_name: VRF name (string)
        :param builtins.str vrf_tenant: VRF tenant (string)
        :param builtins.str apic_refresh_ticker_adjust: APIC refresh ticker adjust amount (string)
        :param builtins.str apic_refresh_time: APIC refresh time in seconds (string)
        :param builtins.str apic_subscription_delay: APIC subscription delay amount (string)
        :param builtins.str capic: cAPIC cloud (string)
        :param builtins.str controller_log_level: Log level for ACI controller (string)
        :param builtins.str disable_periodic_snat_global_info_sync: Whether to disable periodic SNAT global info sync (string)
        :param builtins.str disable_wait_for_network: Whether to disable waiting for network (string)
        :param builtins.str drop_log_enable: Whether to enable drop log (string)
        :param builtins.str duration_wait_for_network: The duration to wait for network (string)
        :param builtins.str enable_endpoint_slice: Whether to enable endpoint slices (string)
        :param builtins.str ep_registry: EP registry (string)
        :param builtins.str gbp_pod_subnet: GBH pod subnet (string)
        :param builtins.str host_agent_log_level: Log level for ACI host agent (string)
        :param builtins.str image_pull_policy: Image pull policy (string)
        :param builtins.str image_pull_secret: Image pull policy (string)
        :param builtins.str infra_vlan: The VLAN used by ACI infra (string)
        :param builtins.str install_istio: Whether to install Istio (string)
        :param builtins.str istio_profile: Istio profile name (string)
        :param Sequence[builtins.str] kafka_brokers: List of Kafka broker hosts (list)
        :param builtins.str kafka_client_crt: Kafka client certificate (string)
        :param builtins.str kafka_client_key: Kafka client key (string)
        :param builtins.str max_nodes_svc_graph: Max nodes in service graph (string)
        :param builtins.str mtu_head_room: MTU head room amount (string)
        :param builtins.str multus_disable: Whether to disable Multus (string)
        :param builtins.str no_priority_class: Whether to use priority class (string)
        :param builtins.str node_pod_if_enable: Whether to enable node pod interface (string)
        :param builtins.str opflex_client_ssl: Whether to use client SSL for Opflex (string)
        :param builtins.str opflex_device_delete_timeout: Opflex device delete timeout (string)
        :param builtins.str opflex_log_level: Log level for ACI opflex (string)
        :param builtins.str opflex_mode: Opflex mode (string)
        :param builtins.str opflex_server_port: Opflex server port (string)
        :param builtins.str overlay_vrf_name: Overlay VRF name (string)
        :param builtins.str ovs_memory_limit: OVS memory limit (string)
        :param builtins.str pbr_tracking_non_snat: Policy-based routing tracking non snat (string)
        :param builtins.str pod_subnet_chunk_size: Pod subnet chunk size (string)
        :param builtins.str run_gbp_container: Whether to run GBP container (string)
        :param builtins.str run_opflex_server_container: Whether to run Opflex server container (string)
        :param builtins.str service_monitor_interval: Service monitor interval (string)
        :param builtins.str snat_contract_scope: Snat contract scope (string)
        :param builtins.str snat_namespace: Snat namespace (string)
        :param builtins.str snat_port_range_end: End of snat port range (string)
        :param builtins.str snat_port_range_start: End of snat port range (string)
        :param builtins.str snat_ports_per_node: Snat ports per node (string)
        :param builtins.str sriov_enable: Whether to enable SR-IOV (string)
        :param builtins.str subnet_domain_name: Subnet domain name (string)
        :param builtins.str tenant: ACI tenant (string)
        :param builtins.str use_aci_anywhere_crd: Whether to use ACI anywhere CRD (string)
        :param builtins.str use_aci_cni_priority_class: Whether to use ACI CNI priority class (string)
        :param builtins.str use_cluster_role: Whether to use cluster role (string)
        :param builtins.str use_host_netns_volume: Whether to use host netns volume (string)
        :param builtins.str use_opflex_server_volume: Whether use Opflex server volume (string)
        :param builtins.str use_privileged_container: Whether ACI containers should run as privileged (string)
        :param builtins.str vmm_controller: VMM controller configuration (string)
        :param builtins.str vmm_domain: VMM domain configuration (string)
        """
        pulumi.set(__self__, "aep", aep)
        pulumi.set(__self__, "apic_hosts", apic_hosts)
        pulumi.set(__self__, "apic_user_crt", apic_user_crt)
        pulumi.set(__self__, "apic_user_key", apic_user_key)
        pulumi.set(__self__, "apic_user_name", apic_user_name)
        pulumi.set(__self__, "encap_type", encap_type)
        pulumi.set(__self__, "extern_dynamic", extern_dynamic)
        pulumi.set(__self__, "extern_static", extern_static)
        pulumi.set(__self__, "kube_api_vlan", kube_api_vlan)
        pulumi.set(__self__, "l3out", l3out)
        pulumi.set(__self__, "l3out_external_networks", l3out_external_networks)
        pulumi.set(__self__, "mcast_range_end", mcast_range_end)
        pulumi.set(__self__, "mcast_range_start", mcast_range_start)
        pulumi.set(__self__, "node_subnet", node_subnet)
        pulumi.set(__self__, "node_svc_subnet", node_svc_subnet)
        pulumi.set(__self__, "service_vlan", service_vlan)
        pulumi.set(__self__, "system_id", system_id)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "vrf_name", vrf_name)
        pulumi.set(__self__, "vrf_tenant", vrf_tenant)
        if apic_refresh_ticker_adjust is not None:
            pulumi.set(__self__, "apic_refresh_ticker_adjust", apic_refresh_ticker_adjust)
        if apic_refresh_time is not None:
            pulumi.set(__self__, "apic_refresh_time", apic_refresh_time)
        if apic_subscription_delay is not None:
            pulumi.set(__self__, "apic_subscription_delay", apic_subscription_delay)
        if capic is not None:
            pulumi.set(__self__, "capic", capic)
        if controller_log_level is not None:
            pulumi.set(__self__, "controller_log_level", controller_log_level)
        if disable_periodic_snat_global_info_sync is not None:
            pulumi.set(__self__, "disable_periodic_snat_global_info_sync", disable_periodic_snat_global_info_sync)
        if disable_wait_for_network is not None:
            pulumi.set(__self__, "disable_wait_for_network", disable_wait_for_network)
        if drop_log_enable is not None:
            pulumi.set(__self__, "drop_log_enable", drop_log_enable)
        if duration_wait_for_network is not None:
            pulumi.set(__self__, "duration_wait_for_network", duration_wait_for_network)
        if enable_endpoint_slice is not None:
            pulumi.set(__self__, "enable_endpoint_slice", enable_endpoint_slice)
        if ep_registry is not None:
            pulumi.set(__self__, "ep_registry", ep_registry)
        if gbp_pod_subnet is not None:
            pulumi.set(__self__, "gbp_pod_subnet", gbp_pod_subnet)
        if host_agent_log_level is not None:
            pulumi.set(__self__, "host_agent_log_level", host_agent_log_level)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if infra_vlan is not None:
            pulumi.set(__self__, "infra_vlan", infra_vlan)
        if install_istio is not None:
            pulumi.set(__self__, "install_istio", install_istio)
        if istio_profile is not None:
            pulumi.set(__self__, "istio_profile", istio_profile)
        if kafka_brokers is not None:
            pulumi.set(__self__, "kafka_brokers", kafka_brokers)
        if kafka_client_crt is not None:
            pulumi.set(__self__, "kafka_client_crt", kafka_client_crt)
        if kafka_client_key is not None:
            pulumi.set(__self__, "kafka_client_key", kafka_client_key)
        if max_nodes_svc_graph is not None:
            pulumi.set(__self__, "max_nodes_svc_graph", max_nodes_svc_graph)
        if mtu_head_room is not None:
            pulumi.set(__self__, "mtu_head_room", mtu_head_room)
        if multus_disable is not None:
            pulumi.set(__self__, "multus_disable", multus_disable)
        if no_priority_class is not None:
            pulumi.set(__self__, "no_priority_class", no_priority_class)
        if node_pod_if_enable is not None:
            pulumi.set(__self__, "node_pod_if_enable", node_pod_if_enable)
        if opflex_client_ssl is not None:
            pulumi.set(__self__, "opflex_client_ssl", opflex_client_ssl)
        if opflex_device_delete_timeout is not None:
            pulumi.set(__self__, "opflex_device_delete_timeout", opflex_device_delete_timeout)
        if opflex_log_level is not None:
            pulumi.set(__self__, "opflex_log_level", opflex_log_level)
        if opflex_mode is not None:
            pulumi.set(__self__, "opflex_mode", opflex_mode)
        if opflex_server_port is not None:
            pulumi.set(__self__, "opflex_server_port", opflex_server_port)
        if overlay_vrf_name is not None:
            pulumi.set(__self__, "overlay_vrf_name", overlay_vrf_name)
        if ovs_memory_limit is not None:
            pulumi.set(__self__, "ovs_memory_limit", ovs_memory_limit)
        if pbr_tracking_non_snat is not None:
            pulumi.set(__self__, "pbr_tracking_non_snat", pbr_tracking_non_snat)
        if pod_subnet_chunk_size is not None:
            pulumi.set(__self__, "pod_subnet_chunk_size", pod_subnet_chunk_size)
        if run_gbp_container is not None:
            pulumi.set(__self__, "run_gbp_container", run_gbp_container)
        if run_opflex_server_container is not None:
            pulumi.set(__self__, "run_opflex_server_container", run_opflex_server_container)
        if service_monitor_interval is not None:
            pulumi.set(__self__, "service_monitor_interval", service_monitor_interval)
        if snat_contract_scope is not None:
            pulumi.set(__self__, "snat_contract_scope", snat_contract_scope)
        if snat_namespace is not None:
            pulumi.set(__self__, "snat_namespace", snat_namespace)
        if snat_port_range_end is not None:
            pulumi.set(__self__, "snat_port_range_end", snat_port_range_end)
        if snat_port_range_start is not None:
            pulumi.set(__self__, "snat_port_range_start", snat_port_range_start)
        if snat_ports_per_node is not None:
            pulumi.set(__self__, "snat_ports_per_node", snat_ports_per_node)
        if sriov_enable is not None:
            pulumi.set(__self__, "sriov_enable", sriov_enable)
        if subnet_domain_name is not None:
            pulumi.set(__self__, "subnet_domain_name", subnet_domain_name)
        if tenant is not None:
            pulumi.set(__self__, "tenant", tenant)
        if use_aci_anywhere_crd is not None:
            pulumi.set(__self__, "use_aci_anywhere_crd", use_aci_anywhere_crd)
        if use_aci_cni_priority_class is not None:
            pulumi.set(__self__, "use_aci_cni_priority_class", use_aci_cni_priority_class)
        if use_cluster_role is not None:
            pulumi.set(__self__, "use_cluster_role", use_cluster_role)
        if use_host_netns_volume is not None:
            pulumi.set(__self__, "use_host_netns_volume", use_host_netns_volume)
        if use_opflex_server_volume is not None:
            pulumi.set(__self__, "use_opflex_server_volume", use_opflex_server_volume)
        if use_privileged_container is not None:
            pulumi.set(__self__, "use_privileged_container", use_privileged_container)
        if vmm_controller is not None:
            pulumi.set(__self__, "vmm_controller", vmm_controller)
        if vmm_domain is not None:
            pulumi.set(__self__, "vmm_domain", vmm_domain)

    @property
    @pulumi.getter
    def aep(self) -> builtins.str:
        """
        Attachable entity profile (string)
        """
        return pulumi.get(self, "aep")

    @property
    @pulumi.getter(name="apicHosts")
    def apic_hosts(self) -> Sequence[builtins.str]:
        """
        List of APIC hosts to connect for APIC API (list)
        """
        return pulumi.get(self, "apic_hosts")

    @property
    @pulumi.getter(name="apicUserCrt")
    def apic_user_crt(self) -> builtins.str:
        """
        APIC user certificate (string)
        """
        return pulumi.get(self, "apic_user_crt")

    @property
    @pulumi.getter(name="apicUserKey")
    def apic_user_key(self) -> builtins.str:
        """
        APIC user key (string)
        """
        return pulumi.get(self, "apic_user_key")

    @property
    @pulumi.getter(name="apicUserName")
    def apic_user_name(self) -> builtins.str:
        """
        APIC user name (string)
        """
        return pulumi.get(self, "apic_user_name")

    @property
    @pulumi.getter(name="encapType")
    def encap_type(self) -> builtins.str:
        """
        Encap type: vxlan or vlan (string)
        """
        return pulumi.get(self, "encap_type")

    @property
    @pulumi.getter(name="externDynamic")
    def extern_dynamic(self) -> builtins.str:
        """
        Subnet to use for dynamic external IPs (string)
        """
        return pulumi.get(self, "extern_dynamic")

    @property
    @pulumi.getter(name="externStatic")
    def extern_static(self) -> builtins.str:
        """
        Subnet to use for static external IPs (string)
        """
        return pulumi.get(self, "extern_static")

    @property
    @pulumi.getter(name="kubeApiVlan")
    def kube_api_vlan(self) -> builtins.str:
        """
        The VLAN used by the physdom for nodes (string)
        """
        return pulumi.get(self, "kube_api_vlan")

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

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

    @property
    @pulumi.getter(name="mcastRangeEnd")
    def mcast_range_end(self) -> builtins.str:
        """
        End of mcast range (string)
        """
        return pulumi.get(self, "mcast_range_end")

    @property
    @pulumi.getter(name="mcastRangeStart")
    def mcast_range_start(self) -> builtins.str:
        """
        Start of mcast range (string)
        """
        return pulumi.get(self, "mcast_range_start")

    @property
    @pulumi.getter(name="nodeSubnet")
    def node_subnet(self) -> builtins.str:
        """
        Subnet to use for nodes (string)
        """
        return pulumi.get(self, "node_subnet")

    @property
    @pulumi.getter(name="nodeSvcSubnet")
    def node_svc_subnet(self) -> builtins.str:
        """
        Subnet to use for service graph (string)
        """
        return pulumi.get(self, "node_svc_subnet")

    @property
    @pulumi.getter(name="serviceVlan")
    def service_vlan(self) -> builtins.str:
        """
        The VLAN used by LoadBalancer services (string)
        """
        return pulumi.get(self, "service_vlan")

    @property
    @pulumi.getter(name="systemId")
    def system_id(self) -> builtins.str:
        """
        ACI system ID (string)
        """
        return pulumi.get(self, "system_id")

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

    @property
    @pulumi.getter(name="vrfName")
    def vrf_name(self) -> builtins.str:
        """
        VRF name (string)
        """
        return pulumi.get(self, "vrf_name")

    @property
    @pulumi.getter(name="vrfTenant")
    def vrf_tenant(self) -> builtins.str:
        """
        VRF tenant (string)
        """
        return pulumi.get(self, "vrf_tenant")

    @property
    @pulumi.getter(name="apicRefreshTickerAdjust")
    def apic_refresh_ticker_adjust(self) -> Optional[builtins.str]:
        """
        APIC refresh ticker adjust amount (string)
        """
        return pulumi.get(self, "apic_refresh_ticker_adjust")

    @property
    @pulumi.getter(name="apicRefreshTime")
    def apic_refresh_time(self) -> Optional[builtins.str]:
        """
        APIC refresh time in seconds (string)
        """
        return pulumi.get(self, "apic_refresh_time")

    @property
    @pulumi.getter(name="apicSubscriptionDelay")
    def apic_subscription_delay(self) -> Optional[builtins.str]:
        """
        APIC subscription delay amount (string)
        """
        return pulumi.get(self, "apic_subscription_delay")

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

    @property
    @pulumi.getter(name="controllerLogLevel")
    def controller_log_level(self) -> Optional[builtins.str]:
        """
        Log level for ACI controller (string)
        """
        return pulumi.get(self, "controller_log_level")

    @property
    @pulumi.getter(name="disablePeriodicSnatGlobalInfoSync")
    def disable_periodic_snat_global_info_sync(self) -> Optional[builtins.str]:
        """
        Whether to disable periodic SNAT global info sync (string)
        """
        return pulumi.get(self, "disable_periodic_snat_global_info_sync")

    @property
    @pulumi.getter(name="disableWaitForNetwork")
    def disable_wait_for_network(self) -> Optional[builtins.str]:
        """
        Whether to disable waiting for network (string)
        """
        return pulumi.get(self, "disable_wait_for_network")

    @property
    @pulumi.getter(name="dropLogEnable")
    def drop_log_enable(self) -> Optional[builtins.str]:
        """
        Whether to enable drop log (string)
        """
        return pulumi.get(self, "drop_log_enable")

    @property
    @pulumi.getter(name="durationWaitForNetwork")
    def duration_wait_for_network(self) -> Optional[builtins.str]:
        """
        The duration to wait for network (string)
        """
        return pulumi.get(self, "duration_wait_for_network")

    @property
    @pulumi.getter(name="enableEndpointSlice")
    def enable_endpoint_slice(self) -> Optional[builtins.str]:
        """
        Whether to enable endpoint slices (string)
        """
        return pulumi.get(self, "enable_endpoint_slice")

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

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

    @property
    @pulumi.getter(name="hostAgentLogLevel")
    def host_agent_log_level(self) -> Optional[builtins.str]:
        """
        Log level for ACI host agent (string)
        """
        return pulumi.get(self, "host_agent_log_level")

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

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

    @property
    @pulumi.getter(name="infraVlan")
    def infra_vlan(self) -> Optional[builtins.str]:
        """
        The VLAN used by ACI infra (string)
        """
        return pulumi.get(self, "infra_vlan")

    @property
    @pulumi.getter(name="installIstio")
    def install_istio(self) -> Optional[builtins.str]:
        """
        Whether to install Istio (string)
        """
        return pulumi.get(self, "install_istio")

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

    @property
    @pulumi.getter(name="kafkaBrokers")
    def kafka_brokers(self) -> Optional[Sequence[builtins.str]]:
        """
        List of Kafka broker hosts (list)
        """
        return pulumi.get(self, "kafka_brokers")

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

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

    @property
    @pulumi.getter(name="maxNodesSvcGraph")
    def max_nodes_svc_graph(self) -> Optional[builtins.str]:
        """
        Max nodes in service graph (string)
        """
        return pulumi.get(self, "max_nodes_svc_graph")

    @property
    @pulumi.getter(name="mtuHeadRoom")
    def mtu_head_room(self) -> Optional[builtins.str]:
        """
        MTU head room amount (string)
        """
        return pulumi.get(self, "mtu_head_room")

    @property
    @pulumi.getter(name="multusDisable")
    def multus_disable(self) -> Optional[builtins.str]:
        """
        Whether to disable Multus (string)
        """
        return pulumi.get(self, "multus_disable")

    @property
    @pulumi.getter(name="noPriorityClass")
    def no_priority_class(self) -> Optional[builtins.str]:
        """
        Whether to use priority class (string)
        """
        return pulumi.get(self, "no_priority_class")

    @property
    @pulumi.getter(name="nodePodIfEnable")
    def node_pod_if_enable(self) -> Optional[builtins.str]:
        """
        Whether to enable node pod interface (string)
        """
        return pulumi.get(self, "node_pod_if_enable")

    @property
    @pulumi.getter(name="opflexClientSsl")
    def opflex_client_ssl(self) -> Optional[builtins.str]:
        """
        Whether to use client SSL for Opflex (string)
        """
        return pulumi.get(self, "opflex_client_ssl")

    @property
    @pulumi.getter(name="opflexDeviceDeleteTimeout")
    def opflex_device_delete_timeout(self) -> Optional[builtins.str]:
        """
        Opflex device delete timeout (string)
        """
        return pulumi.get(self, "opflex_device_delete_timeout")

    @property
    @pulumi.getter(name="opflexLogLevel")
    def opflex_log_level(self) -> Optional[builtins.str]:
        """
        Log level for ACI opflex (string)
        """
        return pulumi.get(self, "opflex_log_level")

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

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

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

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

    @property
    @pulumi.getter(name="pbrTrackingNonSnat")
    def pbr_tracking_non_snat(self) -> Optional[builtins.str]:
        """
        Policy-based routing tracking non snat (string)
        """
        return pulumi.get(self, "pbr_tracking_non_snat")

    @property
    @pulumi.getter(name="podSubnetChunkSize")
    def pod_subnet_chunk_size(self) -> Optional[builtins.str]:
        """
        Pod subnet chunk size (string)
        """
        return pulumi.get(self, "pod_subnet_chunk_size")

    @property
    @pulumi.getter(name="runGbpContainer")
    def run_gbp_container(self) -> Optional[builtins.str]:
        """
        Whether to run GBP container (string)
        """
        return pulumi.get(self, "run_gbp_container")

    @property
    @pulumi.getter(name="runOpflexServerContainer")
    def run_opflex_server_container(self) -> Optional[builtins.str]:
        """
        Whether to run Opflex server container (string)
        """
        return pulumi.get(self, "run_opflex_server_container")

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

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

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

    @property
    @pulumi.getter(name="snatPortRangeEnd")
    def snat_port_range_end(self) -> Optional[builtins.str]:
        """
        End of snat port range (string)
        """
        return pulumi.get(self, "snat_port_range_end")

    @property
    @pulumi.getter(name="snatPortRangeStart")
    def snat_port_range_start(self) -> Optional[builtins.str]:
        """
        End of snat port range (string)
        """
        return pulumi.get(self, "snat_port_range_start")

    @property
    @pulumi.getter(name="snatPortsPerNode")
    def snat_ports_per_node(self) -> Optional[builtins.str]:
        """
        Snat ports per node (string)
        """
        return pulumi.get(self, "snat_ports_per_node")

    @property
    @pulumi.getter(name="sriovEnable")
    def sriov_enable(self) -> Optional[builtins.str]:
        """
        Whether to enable SR-IOV (string)
        """
        return pulumi.get(self, "sriov_enable")

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

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

    @property
    @pulumi.getter(name="useAciAnywhereCrd")
    def use_aci_anywhere_crd(self) -> Optional[builtins.str]:
        """
        Whether to use ACI anywhere CRD (string)
        """
        return pulumi.get(self, "use_aci_anywhere_crd")

    @property
    @pulumi.getter(name="useAciCniPriorityClass")
    def use_aci_cni_priority_class(self) -> Optional[builtins.str]:
        """
        Whether to use ACI CNI priority class (string)
        """
        return pulumi.get(self, "use_aci_cni_priority_class")

    @property
    @pulumi.getter(name="useClusterRole")
    def use_cluster_role(self) -> Optional[builtins.str]:
        """
        Whether to use cluster role (string)
        """
        return pulumi.get(self, "use_cluster_role")

    @property
    @pulumi.getter(name="useHostNetnsVolume")
    def use_host_netns_volume(self) -> Optional[builtins.str]:
        """
        Whether to use host netns volume (string)
        """
        return pulumi.get(self, "use_host_netns_volume")

    @property
    @pulumi.getter(name="useOpflexServerVolume")
    def use_opflex_server_volume(self) -> Optional[builtins.str]:
        """
        Whether use Opflex server volume (string)
        """
        return pulumi.get(self, "use_opflex_server_volume")

    @property
    @pulumi.getter(name="usePrivilegedContainer")
    def use_privileged_container(self) -> Optional[builtins.str]:
        """
        Whether ACI containers should run as privileged (string)
        """
        return pulumi.get(self, "use_privileged_container")

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

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


@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[builtins.str] = None):
        """
        :param builtins.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[builtins.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[builtins.str] = None):
        """
        :param builtins.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[builtins.str]:
        """
        Iface config Flannel network provider (string)
        """
        return pulumi.get(self, "iface")


@pulumi.output_type
class ClusterRkeConfigNetworkFlannelNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[builtins.str] = None):
        """
        :param builtins.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[builtins.str]:
        """
        Iface config Flannel network provider (string)
        """
        return pulumi.get(self, "iface")


@pulumi.output_type
class ClusterRkeConfigNetworkToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str effect: The GKE taint effect (string)
        :param builtins.str operator: The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
        :param builtins.int seconds: The toleration seconds (int)
        :param builtins.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) -> builtins.str:
        """
        The GKE taint key (string)
        """
        return pulumi.get(self, "key")

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

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

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

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


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

    @property
    @pulumi.getter
    def password(self) -> builtins.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: builtins.str,
                 roles: Sequence[builtins.str],
                 user: builtins.str,
                 docker_socket: Optional[builtins.str] = None,
                 hostname_override: Optional[builtins.str] = None,
                 internal_address: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 node_id: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None,
                 ssh_key: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.str] = None):
        """
        :param builtins.str address: Address ip for node (string)
        :param Sequence[builtins.str] roles: Roles for the node. `controlplane`, `etcd` and `worker` are supported. (list)
        :param builtins.str user: Registry user (string)
        :param builtins.str docker_socket: Docker socket for node (string)
        :param builtins.str hostname_override: Hostname override for node (string)
        :param builtins.str internal_address: Internal ip for node (string)
        :param Mapping[str, builtins.str] labels: Labels for the Cluster (map)
        :param builtins.str node_id: Id for the node (string)
        :param builtins.str port: Port for node. Default `22` (string)
        :param builtins.bool ssh_agent_auth: Use ssh agent auth. Default `false` (bool)
        :param builtins.str ssh_key: Node SSH private key (string)
        :param builtins.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) -> builtins.str:
        """
        Address ip for node (string)
        """
        return pulumi.get(self, "address")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.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[builtins.str]:
        """
        Node SSH private key (string)
        """
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[builtins.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: builtins.str,
                 ecr_credential_plugin: Optional['outputs.ClusterRkeConfigPrivateRegistryEcrCredentialPlugin'] = None,
                 is_default: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 user: Optional[builtins.str] = None):
        """
        :param builtins.str url: Registry URL (string)
        :param 'ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs' ecr_credential_plugin: ECR credential plugin config
        :param builtins.bool is_default: Set as default registry. Default `false` (bool)
        :param builtins.str password: Registry password (string)
        :param builtins.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) -> builtins.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
        """
        return pulumi.get(self, "ecr_credential_plugin")

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

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

    @property
    @pulumi.getter
    def user(self) -> Optional[builtins.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[builtins.str] = None,
                 aws_secret_access_key: Optional[builtins.str] = None,
                 aws_session_token: Optional[builtins.str] = None):
        """
        :param builtins.str aws_access_key_id: AWS access key ID (string)
        :param builtins.str aws_secret_access_key: AWS secret access key (string)
        :param builtins.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[builtins.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[builtins.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[builtins.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[builtins.str] = None,
                 cert: Optional[builtins.str] = None,
                 creation: Optional[builtins.str] = None,
                 external_urls: Optional[Sequence[builtins.str]] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 gid: Optional[builtins.int] = None,
                 image: Optional[builtins.str] = None,
                 key: Optional[builtins.str] = None,
                 path: Optional[builtins.str] = None,
                 retention: Optional[builtins.str] = None,
                 snapshot: Optional[builtins.bool] = None,
                 uid: Optional[builtins.int] = None):
        """
        :param 'ClusterRkeConfigServicesEtcdBackupConfigArgs' backup_config: Backup options for etcd service. For Rancher v2.2.x (list maxitems:1)
        :param builtins.str ca_cert: (Computed/Sensitive) K8s cluster ca cert (string)
        :param builtins.str cert: TLS certificate for etcd service (string)
        :param builtins.str creation: Creation option for etcd service (string)
        :param Sequence[builtins.str] external_urls: External urls for etcd service (list)
        :param Mapping[str, builtins.str] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[builtins.str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[builtins.str] extra_envs: Extra environment for scheduler service (list)
        :param builtins.int gid: Etcd service GID. Default: `0`. For Rancher v2.3.x and above (int)
        :param builtins.str image: Docker image for scheduler service (string)
        :param builtins.str key: The GKE taint key (string)
        :param builtins.str path: (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        :param builtins.str retention: Retention for etcd backup. Default `6` (int)
        :param builtins.bool snapshot: Snapshot option for etcd service (bool)
        :param builtins.int uid: Etcd service UID. Default: `0`. For Rancher v2.3.x and 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. For Rancher v2.2.x (list maxitems:1)
        """
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> Optional[builtins.str]:
        """
        (Computed/Sensitive) K8s cluster ca cert (string)
        """
        return pulumi.get(self, "ca_cert")

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

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

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[builtins.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, builtins.str]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

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

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

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

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

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

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.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[builtins.str]:
        """
        Retention for etcd backup. Default `6` (int)
        """
        return pulumi.get(self, "retention")

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

    @property
    @pulumi.getter
    def uid(self) -> Optional[builtins.int]:
        """
        Etcd service UID. Default: `0`. For Rancher v2.3.x and 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[builtins.bool] = None,
                 interval_hours: Optional[builtins.int] = None,
                 retention: Optional[builtins.int] = None,
                 s3_backup_config: Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.bool enabled: Enable the authorized cluster endpoint. Default `true` (bool)
        :param builtins.int interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param builtins.int retention: Retention for etcd backup. Default `6` (int)
        :param 'ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigArgs' s3_backup_config: S3 config options for etcd backup (list maxitems:1)
        :param builtins.bool safe_timestamp: Safe timestamp for etcd backup. Default: `false` (bool)
        :param builtins.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[builtins.bool]:
        """
        Enable the authorized cluster endpoint. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def retention(self) -> Optional[builtins.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[builtins.bool]:
        """
        Safe timestamp for etcd backup. Default: `false` (bool)
        """
        return pulumi.get(self, "safe_timestamp")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.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: builtins.str,
                 endpoint: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 custom_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.str] = None):
        """
        :param builtins.str bucket_name: Bucket name for S3 service (string)
        :param builtins.str endpoint: Endpoint for S3 service (string)
        :param builtins.str access_key: The AWS Client ID to use (string)
        :param builtins.str custom_ca: Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        :param builtins.str folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param builtins.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 builtins.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) -> builtins.str:
        """
        Bucket name for S3 service (string)
        """
        return pulumi.get(self, "bucket_name")

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

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

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[builtins.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[builtins.str]:
        """
        Folder for S3 service. Available from Rancher v2.2.7 (string)
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.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[builtins.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 == "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['outputs.ClusterRkeConfigServicesKubeApiAdmissionConfiguration'] = None,
                 always_pull_images: Optional[builtins.bool] = None,
                 audit_log: Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLog'] = None,
                 event_rate_limit: Optional['outputs.ClusterRkeConfigServicesKubeApiEventRateLimit'] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.str] = None,
                 secrets_encryption_config: Optional['outputs.ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig'] = None,
                 service_cluster_ip_range: Optional[builtins.str] = None,
                 service_node_port_range: Optional[builtins.str] = None):
        """
        :param 'ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs' admission_configuration: Cluster admission configuration
        :param builtins.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, builtins.str] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[builtins.str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[builtins.str] extra_envs: Extra environment for scheduler service (list)
        :param builtins.str image: Docker image for scheduler service (string)
        :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 builtins.str service_cluster_ip_range: Service Cluster ip Range option for kube controller service (string)
        :param builtins.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 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['outputs.ClusterRkeConfigServicesKubeApiAdmissionConfiguration']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[builtins.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, builtins.str]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

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

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

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

    @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[builtins.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[builtins.str]:
        """
        Service Node Port Range option for kube API service (string)
        """
        return pulumi.get(self, "service_node_port_range")


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiAdmissionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

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

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

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

    def __init__(__self__, *,
                 api_version: Optional[builtins.str] = None,
                 kind: Optional[builtins.str] = None,
                 plugins: Optional[Sequence['outputs.ClusterRkeConfigServicesKubeApiAdmissionConfigurationPlugin']] = None):
        """
        :param builtins.str api_version: Admission configuration ApiVersion
        :param builtins.str kind: Admission configuration Kind
        :param Sequence['ClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs'] plugins: Admission configuration plugins
        """
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if plugins is not None:
            pulumi.set(__self__, "plugins", plugins)

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

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

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


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

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

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

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


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiAuditLog(dict):
    def __init__(__self__, *,
                 configuration: Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLogConfiguration'] = None,
                 enabled: Optional[builtins.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:
               
               ```
               configuration = <<EOF
               apiVersion: eventratelimit.admission.k8s.io/v1alpha1
               kind: Configuration
               limits:
               - type: Server
               burst: 35000
               qps: 6000
               EOF
               ```
        :param builtins.bool enabled: Enable the authorized cluster endpoint. 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.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:

        ```
        configuration = <<EOF
        apiVersion: eventratelimit.admission.k8s.io/v1alpha1
        kind: Configuration
        limits:
        - type: Server
        burst: 35000
        qps: 6000
        EOF
        ```
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable the authorized cluster endpoint. Default `true` (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[builtins.str] = None,
                 max_age: Optional[builtins.int] = None,
                 max_backup: Optional[builtins.int] = None,
                 max_size: Optional[builtins.int] = None,
                 path: Optional[builtins.str] = None,
                 policy: Optional[builtins.str] = None):
        """
        :param builtins.str format: Audit log format. Default: 'json' (string)
        :param builtins.int max_age: Audit log max age. Default: `30` (int)
        :param builtins.int max_backup: Audit log max backup. Default: `10` (int)
        :param builtins.int max_size: The EKS node group maximum size. Default `2` (int)
        :param builtins.str path: (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
        :param builtins.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:
               
               ```
               policy = <<EOF
               apiVersion: audit.k8s.io/v1
               kind: Policy
               rules:
               - level: RequestResponse
               resources:
               - resources:
               - pods
               EOF
               ```
        """
        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[builtins.str]:
        """
        Audit log format. Default: 'json' (string)
        """
        return pulumi.get(self, "format")

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

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

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

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.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[builtins.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:

        ```
        policy = <<EOF
        apiVersion: audit.k8s.io/v1
        kind: Policy
        rules:
        - level: RequestResponse
        resources:
        - resources:
        - pods
        EOF
        ```
        """
        return pulumi.get(self, "policy")


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiEventRateLimit(dict):
    def __init__(__self__, *,
                 configuration: Optional[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None):
        """
        :param builtins.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:
               
               ```
               configuration = <<EOF
               apiVersion: eventratelimit.admission.k8s.io/v1alpha1
               kind: Configuration
               limits:
               - type: Server
               burst: 35000
               qps: 6000
               EOF
               ```
        :param builtins.bool enabled: Enable the authorized cluster endpoint. 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[builtins.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:

        ```
        configuration = <<EOF
        apiVersion: eventratelimit.admission.k8s.io/v1alpha1
        kind: Configuration
        limits:
        - type: Server
        burst: 35000
        qps: 6000
        EOF
        ```
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable the authorized cluster endpoint. Default `true` (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[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None):
        """
        :param builtins.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:
               
               ```
               custom_config = <<EOF
               apiVersion: apiserver.config.k8s.io/v1
               kind: EncryptionConfiguration
               resources:
               - resources:
               - secrets
               providers:
               - aescbc:
               keys:
               - name: k-fw5hn
               secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=
               identity: {}
               EOF
               
               ```
        :param builtins.bool enabled: Enable the authorized cluster endpoint. 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[builtins.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:

        ```
        custom_config = <<EOF
        apiVersion: apiserver.config.k8s.io/v1
        kind: EncryptionConfiguration
        resources:
        - resources:
        - secrets
        providers:
        - aescbc:
        keys:
        - name: k-fw5hn
        secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=
        identity: {}
        EOF

        ```
        """
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable the authorized cluster endpoint. Default `true` (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[builtins.str] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.str] = None,
                 service_cluster_ip_range: Optional[builtins.str] = None):
        """
        :param builtins.str cluster_cidr: Cluster CIDR option for kube controller service (string)
        :param Mapping[str, builtins.str] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[builtins.str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[builtins.str] extra_envs: Extra environment for scheduler service (list)
        :param builtins.str image: Docker image for scheduler service (string)
        :param builtins.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[builtins.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, builtins.str]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

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

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

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

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[builtins.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[builtins.str] = None,
                 cluster_domain: Optional[builtins.str] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 fail_swap_on: Optional[builtins.bool] = None,
                 generate_serving_certificate: Optional[builtins.bool] = None,
                 image: Optional[builtins.str] = None,
                 infra_container_image: Optional[builtins.str] = None):
        """
        :param builtins.str cluster_dns_server: Cluster DNS Server option for kubelet service (string)
        :param builtins.str cluster_domain: Cluster Domain option for kubelet service (string)
        :param Mapping[str, builtins.str] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[builtins.str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[builtins.str] extra_envs: Extra environment for scheduler service (list)
        :param builtins.bool fail_swap_on: Enable or disable failing when swap on is not supported (bool)
        :param builtins.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 builtins.str image: Docker image for scheduler service (string)
        :param builtins.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[builtins.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[builtins.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, builtins.str]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

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

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

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> Optional[builtins.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[builtins.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[builtins.str]:
        """
        Docker image for scheduler service (string)
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> Optional[builtins.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, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.str] = None):
        """
        :param Mapping[str, builtins.str] extra_args: Extra arguments for scheduler service (map)
        :param Sequence[builtins.str] extra_binds: Extra binds for scheduler service (list)
        :param Sequence[builtins.str] extra_envs: Extra environment for scheduler service (list)
        :param builtins.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, builtins.str]]:
        """
        Extra arguments for scheduler service (map)
        """
        return pulumi.get(self, "extra_args")

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

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

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

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

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

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.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[builtins.bool] = None,
                 drain_input: Optional['outputs.ClusterRkeConfigUpgradeStrategyDrainInput'] = None,
                 max_unavailable_controlplane: Optional[builtins.str] = None,
                 max_unavailable_worker: Optional[builtins.str] = None):
        """
        :param builtins.bool drain: RKE drain nodes. Default: `false` (bool)
        :param 'ClusterRkeConfigUpgradeStrategyDrainInputArgs' drain_input: RKE drain node input (list Maxitems: 1)
        :param builtins.str max_unavailable_controlplane: RKE max unavailable controlplane nodes. Default: `1` (string)
        :param builtins.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[builtins.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[builtins.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[builtins.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[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 grace_period: Optional[builtins.int] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.bool delete_local_data: Delete RKE node local data. Default: `false` (bool)
        :param builtins.bool force: Force RKE node drain. Default: `false` (bool)
        :param builtins.int grace_period: RKE node drain grace period. Default: `-1` (int)
        :param builtins.bool ignore_daemon_sets: Ignore RKE daemon sets. Default: `true` (bool)
        :param builtins.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[builtins.bool]:
        """
        Delete RKE node local data. Default: `false` (bool)
        """
        return pulumi.get(self, "delete_local_data")

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

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[builtins.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[builtins.bool]:
        """
        Ignore RKE daemon sets. Default: `true` (bool)
        """
        return pulumi.get(self, "ignore_daemon_sets")

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


@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, builtins.str]] = None,
                 capacity: Optional[Mapping[str, builtins.str]] = None,
                 cluster_id: Optional[builtins.str] = None,
                 external_ip_address: Optional[builtins.str] = None,
                 hostname: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 ip_address: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 name: Optional[builtins.str] = None,
                 node_pool_id: Optional[builtins.str] = None,
                 node_template_id: Optional[builtins.str] = None,
                 provider_id: Optional[builtins.str] = None,
                 requested_hostname: Optional[builtins.str] = None,
                 roles: Optional[Sequence[builtins.str]] = None,
                 ssh_user: Optional[builtins.str] = None,
                 system_info: Optional[Mapping[str, builtins.str]] = None):
        """
        :param Mapping[str, builtins.str] annotations: Annotations of the resource
        :param Mapping[str, builtins.str] capacity: The total resources of a node (map).
        :param builtins.str cluster_id: The cluster ID that is syncing (string)
        :param builtins.str external_ip_address: The external IP address of the node (string).
        :param builtins.str hostname: The hostname of the node (string).
        :param builtins.str id: (Computed) The ID of the resource. Same as `cluster_id` (string)
        :param builtins.str ip_address: The private IP address of the node (string).
        :param Mapping[str, builtins.str] labels: Labels of the resource
        :param builtins.str name: The name of the node (string).
        :param builtins.str node_pool_id: The Node Pool ID of the node (string).
        :param builtins.str node_template_id: The Node Template ID of the node (string).
        :param builtins.str provider_id: The Provider ID of the node (string).
        :param builtins.str requested_hostname: The requested hostname (string).
        :param Sequence[builtins.str] roles: Roles of the node. `controlplane`, `etcd` and `worker`. (list)
        :param builtins.str ssh_user: The user to connect to the node (string).
        :param Mapping[str, builtins.str] 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, builtins.str]]:
        """
        Annotations of the resource
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter
    def capacity(self) -> Optional[Mapping[str, builtins.str]]:
        """
        The total resources of a node (map).
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[builtins.str]:
        """
        The cluster ID that is syncing (string)
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="externalIpAddress")
    def external_ip_address(self) -> Optional[builtins.str]:
        """
        The external IP address of the node (string).
        """
        return pulumi.get(self, "external_ip_address")

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

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

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[builtins.str]:
        """
        The private IP address of the node (string).
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Labels of the resource
        """
        return pulumi.get(self, "labels")

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

    @property
    @pulumi.getter(name="nodePoolId")
    def node_pool_id(self) -> Optional[builtins.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[builtins.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[builtins.str]:
        """
        The Provider ID of the node (string).
        """
        return pulumi.get(self, "provider_id")

    @property
    @pulumi.getter(name="requestedHostname")
    def requested_hostname(self) -> Optional[builtins.str]:
        """
        The requested hostname (string).
        """
        return pulumi.get(self, "requested_hostname")

    @property
    @pulumi.getter
    def roles(self) -> Optional[Sequence[builtins.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[builtins.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, builtins.str]]:
        """
        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[builtins.str] = None,
                 group_principal_id: Optional[builtins.str] = None,
                 user_principal_id: Optional[builtins.str] = None):
        """
        :param builtins.str access_type: Member access type: member, owner, read-only
        :param builtins.str group_principal_id: Member group principal id
        :param builtins.str user_principal_id: Member user principal id
        """
        if access_type is not None:
            pulumi.set(__self__, "access_type", access_type)
        if group_principal_id is not None:
            pulumi.set(__self__, "group_principal_id", group_principal_id)
        if user_principal_id is not None:
            pulumi.set(__self__, "user_principal_id", user_principal_id)

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

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

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[builtins.str]:
        """
        Member user principal id
        """
        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: builtins.str,
                 annotations: Optional[Mapping[str, builtins.str]] = None,
                 cluster_template_id: Optional[builtins.str] = None,
                 default: Optional[builtins.bool] = None,
                 enabled: Optional[builtins.bool] = None,
                 id: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 questions: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionQuestion']] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigArgs' cluster_config: Cluster configuration
        :param builtins.str name: The cluster template name (string)
        :param Mapping[str, builtins.str] annotations: Annotations for the cluster template (map)
        :param builtins.str cluster_template_id: Cluster template ID
        :param builtins.bool default: Default cluster template revision
        :param builtins.bool enabled: Enable cluster template revision
        :param builtins.str id: (Computed) The ID of the resource (string)
        :param Mapping[str, builtins.str] labels: Labels for the cluster template (map)
        :param Sequence['ClusterTemplateTemplateRevisionQuestionArgs'] questions: Cluster template questions
        """
        pulumi.set(__self__, "cluster_config", cluster_config)
        pulumi.set(__self__, "name", name)
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_template_id is not None:
            pulumi.set(__self__, "cluster_template_id", cluster_template_id)
        if default is not None:
            pulumi.set(__self__, "default", default)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if questions is not None:
            pulumi.set(__self__, "questions", questions)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def questions(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionQuestion']]:
        """
        Cluster template questions
        """
        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 == "defaultPodSecurityAdmissionConfigurationTemplateName":
            suggest = "default_pod_security_admission_configuration_template_name"
        elif key == "desiredAgentImage":
            suggest = "desired_agent_image"
        elif key == "desiredAuthImage":
            suggest = "desired_auth_image"
        elif key == "dockerRootDir":
            suggest = "docker_root_dir"
        elif key == "enableNetworkPolicy":
            suggest = "enable_network_policy"
        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[builtins.str] = None,
                 default_pod_security_admission_configuration_template_name: Optional[builtins.str] = None,
                 desired_agent_image: Optional[builtins.str] = None,
                 desired_auth_image: Optional[builtins.str] = None,
                 docker_root_dir: Optional[builtins.str] = None,
                 enable_network_policy: Optional[builtins.bool] = None,
                 windows_prefered_cluster: Optional[builtins.bool] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs' rke_config: Rancher Kubernetes Engine Config
        :param 'ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs' cluster_auth_endpoint: Local cluster auth endpoint
        :param builtins.str default_cluster_role_for_project_members: Default cluster role for project members
        :param builtins.str default_pod_security_admission_configuration_template_name: Default pod security admission configuration template name
        :param builtins.str desired_agent_image: Desired agent image
        :param builtins.str desired_auth_image: Desired auth image
        :param builtins.str docker_root_dir: Docker Root Dir
        :param builtins.bool enable_network_policy: Enable project network isolation
        :param builtins.bool windows_prefered_cluster: Windows prefered cluster
        """
        pulumi.set(__self__, "rke_config", rke_config)
        if cluster_auth_endpoint is not None:
            pulumi.set(__self__, "cluster_auth_endpoint", cluster_auth_endpoint)
        if default_cluster_role_for_project_members is not None:
            pulumi.set(__self__, "default_cluster_role_for_project_members", default_cluster_role_for_project_members)
        if default_pod_security_admission_configuration_template_name is not None:
            pulumi.set(__self__, "default_pod_security_admission_configuration_template_name", default_pod_security_admission_configuration_template_name)
        if 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_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if windows_prefered_cluster is not None:
            pulumi.set(__self__, "windows_prefered_cluster", windows_prefered_cluster)

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

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

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

    @property
    @pulumi.getter(name="defaultPodSecurityAdmissionConfigurationTemplateName")
    def default_pod_security_admission_configuration_template_name(self) -> Optional[builtins.str]:
        """
        Default pod security admission configuration template name
        """
        return pulumi.get(self, "default_pod_security_admission_configuration_template_name")

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

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

    @property
    @pulumi.getter(name="dockerRootDir")
    def docker_root_dir(self) -> Optional[builtins.str]:
        """
        Docker Root Dir
        """
        return pulumi.get(self, "docker_root_dir")

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

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[builtins.bool]:
        """
        Windows prefered cluster
        """
        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[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.str] = None):
        """
        :param builtins.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[builtins.str]:
        return pulumi.get(self, "ca_certs")

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

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[builtins.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[builtins.int] = None,
                 addons: Optional[builtins.str] = None,
                 addons_includes: Optional[Sequence[builtins.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[builtins.bool] = None,
                 ignore_docker_version: Optional[builtins.bool] = None,
                 ingress: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress'] = None,
                 kubernetes_version: Optional[builtins.str] = None,
                 monitoring: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring'] = None,
                 network: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork'] = None,
                 nodes: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode']] = None,
                 prefix_path: Optional[builtins.str] = None,
                 private_registries: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry']] = None,
                 services: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices'] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None,
                 ssh_cert_path: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.str] = None,
                 upgrade_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy'] = None,
                 win_prefix_path: Optional[builtins.str] = None):
        """
        :param builtins.int addon_job_timeout: Optional duration in seconds of addon job.
        :param builtins.str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[builtins.str] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs' authentication: Kubernetes cluster authentication
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs' authorization: Kubernetes cluster authorization
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs' bastion_host: RKE bastion host
        :param builtins.bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param builtins.bool ignore_docker_version: Optional ignore docker version on nodes
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs' ingress: Kubernetes ingress configuration
        :param builtins.str kubernetes_version: Optional kubernetes version to deploy
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs' monitoring: Kubernetes cluster monitoring
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs' network: Kubernetes cluster networking
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs'] nodes: Optional RKE cluster nodes
        :param builtins.str prefix_path: Optional prefix to customize kubernetes path
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs'] private_registries: Optional private registries for docker images
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs' services: Kubernetes cluster services
        :param builtins.bool ssh_agent_auth: Optional use ssh agent auth
        :param builtins.str ssh_cert_path: Optional cluster level SSH certificate path
        :param builtins.str ssh_key_path: Optional cluster level SSH private key path
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param builtins.str win_prefix_path: Optional prefix to customize kubernetes path for windows
        """
        if addon_job_timeout is not None:
            pulumi.set(__self__, "addon_job_timeout", addon_job_timeout)
        if addons is not None:
            pulumi.set(__self__, "addons", addons)
        if addons_includes is not None:
            pulumi.set(__self__, "addons_includes", addons_includes)
        if authentication is not None:
            pulumi.set(__self__, "authentication", authentication)
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if bastion_host is not None:
            pulumi.set(__self__, "bastion_host", bastion_host)
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if enable_cri_dockerd is not None:
            pulumi.set(__self__, "enable_cri_dockerd", enable_cri_dockerd)
        if ignore_docker_version is not None:
            pulumi.set(__self__, "ignore_docker_version", ignore_docker_version)
        if ingress is not None:
            pulumi.set(__self__, "ingress", ingress)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)
        if prefix_path is not None:
            pulumi.set(__self__, "prefix_path", prefix_path)
        if private_registries is not None:
            pulumi.set(__self__, "private_registries", private_registries)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_cert_path is not None:
            pulumi.set(__self__, "ssh_cert_path", ssh_cert_path)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        if win_prefix_path is not None:
            pulumi.set(__self__, "win_prefix_path", win_prefix_path)

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

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

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[Sequence[builtins.str]]:
        """
        Optional addons yaml manisfest to deploy on rke cluster.
        """
        return pulumi.get(self, "addons_includes")

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

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

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost']:
        """
        RKE bastion host
        """
        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[builtins.bool]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

    @property
    @pulumi.getter
    def options(self) -> Optional[Mapping[str, builtins.str]]:
        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: builtins.str,
                 user: builtins.str,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None,
                 ssh_key: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "address")

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

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

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

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

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[builtins.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[builtins.str] = None,
                 name: Optional[builtins.str] = None,
                 openstack_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider'] = None,
                 vsphere_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider'] = None):
        """
        :param builtins.str name: The cluster template name (string)
        """
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if custom_cloud_provider is not None:
            pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['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[builtins.str]:
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        The cluster template 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[builtins.bool] = None,
                 disable_strict_zone_check: Optional[builtins.bool] = None,
                 elb_security_group: Optional[builtins.str] = None,
                 kubernetes_cluster_id: Optional[builtins.str] = None,
                 kubernetes_cluster_tag: Optional[builtins.str] = None,
                 role_arn: Optional[builtins.str] = None,
                 route_table_id: Optional[builtins.str] = None,
                 subnet_id: Optional[builtins.str] = None,
                 vpc: Optional[builtins.str] = None,
                 zone: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "disable_security_group_ingress")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def zone(self) -> Optional[builtins.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: builtins.str,
                 region: Optional[builtins.str] = None,
                 signing_method: Optional[builtins.str] = None,
                 signing_name: Optional[builtins.str] = None,
                 signing_region: Optional[builtins.str] = None,
                 url: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "service")

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

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

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

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

    @property
    @pulumi.getter
    def url(self) -> Optional[builtins.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: builtins.str,
                 aad_client_secret: builtins.str,
                 subscription_id: builtins.str,
                 tenant_id: builtins.str,
                 aad_client_cert_password: Optional[builtins.str] = None,
                 aad_client_cert_path: Optional[builtins.str] = None,
                 cloud: Optional[builtins.str] = None,
                 cloud_provider_backoff: Optional[builtins.bool] = None,
                 cloud_provider_backoff_duration: Optional[builtins.int] = None,
                 cloud_provider_backoff_exponent: Optional[builtins.int] = None,
                 cloud_provider_backoff_jitter: Optional[builtins.int] = None,
                 cloud_provider_backoff_retries: Optional[builtins.int] = None,
                 cloud_provider_rate_limit: Optional[builtins.bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[builtins.int] = None,
                 cloud_provider_rate_limit_qps: Optional[builtins.int] = None,
                 load_balancer_sku: Optional[builtins.str] = None,
                 location: Optional[builtins.str] = None,
                 maximum_load_balancer_rule_count: Optional[builtins.int] = None,
                 primary_availability_set_name: Optional[builtins.str] = None,
                 primary_scale_set_name: Optional[builtins.str] = None,
                 resource_group: Optional[builtins.str] = None,
                 route_table_name: Optional[builtins.str] = None,
                 security_group_name: Optional[builtins.str] = None,
                 subnet_name: Optional[builtins.str] = None,
                 use_instance_metadata: Optional[builtins.bool] = None,
                 use_managed_identity_extension: Optional[builtins.bool] = None,
                 vm_type: Optional[builtins.str] = None,
                 vnet_name: Optional[builtins.str] = None,
                 vnet_resource_group: Optional[builtins.str] = None):
        """
        :param builtins.str load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        pulumi.set(__self__, "aad_client_id", aad_client_id)
        pulumi.set(__self__, "aad_client_secret", aad_client_secret)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if aad_client_cert_password is not None:
            pulumi.set(__self__, "aad_client_cert_password", aad_client_cert_password)
        if aad_client_cert_path is not None:
            pulumi.set(__self__, "aad_client_cert_path", aad_client_cert_path)
        if cloud is not None:
            pulumi.set(__self__, "cloud", cloud)
        if cloud_provider_backoff is not None:
            pulumi.set(__self__, "cloud_provider_backoff", cloud_provider_backoff)
        if cloud_provider_backoff_duration is not None:
            pulumi.set(__self__, "cloud_provider_backoff_duration", cloud_provider_backoff_duration)
        if cloud_provider_backoff_exponent is not None:
            pulumi.set(__self__, "cloud_provider_backoff_exponent", cloud_provider_backoff_exponent)
        if cloud_provider_backoff_jitter is not None:
            pulumi.set(__self__, "cloud_provider_backoff_jitter", cloud_provider_backoff_jitter)
        if cloud_provider_backoff_retries is not None:
            pulumi.set(__self__, "cloud_provider_backoff_retries", cloud_provider_backoff_retries)
        if cloud_provider_rate_limit is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit", cloud_provider_rate_limit)
        if cloud_provider_rate_limit_bucket is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_bucket", cloud_provider_rate_limit_bucket)
        if cloud_provider_rate_limit_qps is not None:
            pulumi.set(__self__, "cloud_provider_rate_limit_qps", cloud_provider_rate_limit_qps)
        if load_balancer_sku is not None:
            pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if maximum_load_balancer_rule_count is not None:
            pulumi.set(__self__, "maximum_load_balancer_rule_count", maximum_load_balancer_rule_count)
        if primary_availability_set_name is not None:
            pulumi.set(__self__, "primary_availability_set_name", primary_availability_set_name)
        if primary_scale_set_name is not None:
            pulumi.set(__self__, "primary_scale_set_name", primary_scale_set_name)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if route_table_name is not None:
            pulumi.set(__self__, "route_table_name", route_table_name)
        if security_group_name is not None:
            pulumi.set(__self__, "security_group_name", security_group_name)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)
        if use_instance_metadata is not None:
            pulumi.set(__self__, "use_instance_metadata", use_instance_metadata)
        if use_managed_identity_extension is not None:
            pulumi.set(__self__, "use_managed_identity_extension", use_managed_identity_extension)
        if vm_type is not None:
            pulumi.set(__self__, "vm_type", vm_type)
        if vnet_name is not None:
            pulumi.set(__self__, "vnet_name", vnet_name)
        if vnet_resource_group is not None:
            pulumi.set(__self__, "vnet_resource_group", vnet_resource_group)

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

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

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

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> builtins.str:
        return pulumi.get(self, "tenant_id")

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[builtins.str]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        return pulumi.get(self, "load_balancer_sku")

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> Optional[builtins.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[builtins.str] = None,
                 ignore_volume_az: Optional[builtins.bool] = None,
                 trust_device_path: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "bs_version")

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

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> Optional[builtins.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: builtins.str,
                 password: builtins.str,
                 username: builtins.str,
                 ca_file: Optional[builtins.str] = None,
                 domain_id: Optional[builtins.str] = None,
                 domain_name: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 tenant_id: Optional[builtins.str] = None,
                 tenant_name: Optional[builtins.str] = None,
                 trust_id: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "auth_url")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> Optional[builtins.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[builtins.bool] = None,
                 floating_network_id: Optional[builtins.str] = None,
                 lb_method: Optional[builtins.str] = None,
                 lb_provider: Optional[builtins.str] = None,
                 lb_version: Optional[builtins.str] = None,
                 manage_security_groups: Optional[builtins.bool] = None,
                 monitor_delay: Optional[builtins.str] = None,
                 monitor_max_retries: Optional[builtins.int] = None,
                 monitor_timeout: Optional[builtins.str] = None,
                 subnet_id: Optional[builtins.str] = None,
                 use_octavia: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "create_monitor")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> Optional[builtins.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[builtins.int] = None,
                 search_order: Optional[builtins.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[builtins.int]:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.str]:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gracefulShutdownTimeout":
            suggest = "graceful_shutdown_timeout"
        elif 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[builtins.str] = None,
                 graceful_shutdown_timeout: Optional[builtins.str] = None,
                 insecure_flag: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 soap_roundtrip_count: Optional[builtins.int] = None,
                 user: Optional[builtins.str] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        if insecure_flag is not None:
            pulumi.set(__self__, "insecure_flag", insecure_flag)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

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

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

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

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

    @property
    @pulumi.getter
    def user(self) -> Optional[builtins.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[builtins.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[builtins.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: builtins.str,
                 name: builtins.str,
                 password: builtins.str,
                 user: builtins.str,
                 port: Optional[builtins.str] = None,
                 soap_roundtrip_count: Optional[builtins.int] = None):
        """
        :param builtins.str name: The cluster template name (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)

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

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

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

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

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

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[builtins.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: builtins.str,
                 folder: builtins.str,
                 server: builtins.str,
                 default_datastore: Optional[builtins.str] = None,
                 resourcepool_path: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "datacenter")

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

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

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

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> Optional[builtins.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, builtins.str]] = None,
                 nodelocal: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal'] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 provider: Optional[builtins.str] = None,
                 reverse_cidrs: Optional[Sequence[builtins.str]] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy'] = None,
                 upstream_nameservers: Optional[Sequence[builtins.str]] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs' linear_autoscaler_params: Linear Autoscaler Params
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs'] tolerations: DNS service tolerations
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

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

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "node_selector")

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

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

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

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "reverse_cidrs")

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

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

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Optional[Sequence[builtins.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[builtins.float] = None,
                 max: Optional[builtins.int] = None,
                 min: Optional[builtins.int] = None,
                 nodes_per_replica: Optional[builtins.float] = None,
                 prevent_single_point_failure: Optional[builtins.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[builtins.float]:
        return pulumi.get(self, "cores_per_replica")

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

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

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

    @property
    @pulumi.getter(name="preventSinglePointFailure")
    def prevent_single_point_failure(self) -> Optional[builtins.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[builtins.str] = None,
                 node_selector: Optional[Mapping[str, builtins.str]] = None):
        """
        :param Mapping[str, builtins.str] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

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

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        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[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        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[builtins.bool] = None,
                 dns_policy: Optional[builtins.str] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 http_port: Optional[builtins.int] = None,
                 https_port: Optional[builtins.int] = None,
                 network_mode: Optional[builtins.str] = None,
                 node_selector: Optional[Mapping[str, builtins.str]] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 provider: Optional[builtins.str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy'] = None):
        """
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs'] tolerations: Ingress add-on tolerations
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs' update_strategy: Update daemon set strategy
        """
        if default_backend is not None:
            pulumi.set(__self__, "default_backend", default_backend)
        if dns_policy is not None:
            pulumi.set(__self__, "dns_policy", dns_policy)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if http_port is not None:
            pulumi.set(__self__, "http_port", http_port)
        if https_port is not None:
            pulumi.set(__self__, "https_port", https_port)
        if network_mode is not None:
            pulumi.set(__self__, "network_mode", network_mode)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

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

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

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "extra_args")

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

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

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

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "node_selector")

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        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[builtins.int] = None):
        """
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        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, builtins.str]] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 provider: Optional[builtins.str] = None,
                 replicas: Optional[builtins.int] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy'] = None):
        """
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs'] tolerations: Monitoring add-on tolerations
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "node_selector")

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.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[builtins.str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        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[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aciNetworkProvider":
            suggest = "aci_network_provider"
        elif 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__, *,
                 aci_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProvider'] = None,
                 calico_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProvider'] = None,
                 canal_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider'] = None,
                 flannel_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider'] = None,
                 mtu: Optional[builtins.int] = None,
                 options: Optional[Mapping[str, builtins.str]] = None,
                 plugin: Optional[builtins.str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration']] = None,
                 weave_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider'] = None):
        """
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs'] tolerations: Network add-on tolerations
        """
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

    @property
    @pulumi.getter(name="aciNetworkProvider")
    def aci_network_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProvider']:
        return pulumi.get(self, "aci_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[builtins.int]:
        return pulumi.get(self, "mtu")

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

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration']]:
        """
        Network add-on tolerations
        """
        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 ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apicHosts":
            suggest = "apic_hosts"
        elif key == "apicUserCrt":
            suggest = "apic_user_crt"
        elif key == "apicUserKey":
            suggest = "apic_user_key"
        elif key == "apicUserName":
            suggest = "apic_user_name"
        elif key == "encapType":
            suggest = "encap_type"
        elif key == "externDynamic":
            suggest = "extern_dynamic"
        elif key == "externStatic":
            suggest = "extern_static"
        elif key == "kubeApiVlan":
            suggest = "kube_api_vlan"
        elif key == "l3outExternalNetworks":
            suggest = "l3out_external_networks"
        elif key == "mcastRangeEnd":
            suggest = "mcast_range_end"
        elif key == "mcastRangeStart":
            suggest = "mcast_range_start"
        elif key == "nodeSubnet":
            suggest = "node_subnet"
        elif key == "nodeSvcSubnet":
            suggest = "node_svc_subnet"
        elif key == "serviceVlan":
            suggest = "service_vlan"
        elif key == "systemId":
            suggest = "system_id"
        elif key == "vrfName":
            suggest = "vrf_name"
        elif key == "vrfTenant":
            suggest = "vrf_tenant"
        elif key == "apicRefreshTickerAdjust":
            suggest = "apic_refresh_ticker_adjust"
        elif key == "apicRefreshTime":
            suggest = "apic_refresh_time"
        elif key == "apicSubscriptionDelay":
            suggest = "apic_subscription_delay"
        elif key == "controllerLogLevel":
            suggest = "controller_log_level"
        elif key == "disablePeriodicSnatGlobalInfoSync":
            suggest = "disable_periodic_snat_global_info_sync"
        elif key == "disableWaitForNetwork":
            suggest = "disable_wait_for_network"
        elif key == "dropLogEnable":
            suggest = "drop_log_enable"
        elif key == "durationWaitForNetwork":
            suggest = "duration_wait_for_network"
        elif key == "enableEndpointSlice":
            suggest = "enable_endpoint_slice"
        elif key == "epRegistry":
            suggest = "ep_registry"
        elif key == "gbpPodSubnet":
            suggest = "gbp_pod_subnet"
        elif key == "hostAgentLogLevel":
            suggest = "host_agent_log_level"
        elif key == "imagePullPolicy":
            suggest = "image_pull_policy"
        elif key == "imagePullSecret":
            suggest = "image_pull_secret"
        elif key == "infraVlan":
            suggest = "infra_vlan"
        elif key == "installIstio":
            suggest = "install_istio"
        elif key == "istioProfile":
            suggest = "istio_profile"
        elif key == "kafkaBrokers":
            suggest = "kafka_brokers"
        elif key == "kafkaClientCrt":
            suggest = "kafka_client_crt"
        elif key == "kafkaClientKey":
            suggest = "kafka_client_key"
        elif key == "maxNodesSvcGraph":
            suggest = "max_nodes_svc_graph"
        elif key == "mtuHeadRoom":
            suggest = "mtu_head_room"
        elif key == "multusDisable":
            suggest = "multus_disable"
        elif key == "noPriorityClass":
            suggest = "no_priority_class"
        elif key == "nodePodIfEnable":
            suggest = "node_pod_if_enable"
        elif key == "opflexClientSsl":
            suggest = "opflex_client_ssl"
        elif key == "opflexDeviceDeleteTimeout":
            suggest = "opflex_device_delete_timeout"
        elif key == "opflexLogLevel":
            suggest = "opflex_log_level"
        elif key == "opflexMode":
            suggest = "opflex_mode"
        elif key == "opflexServerPort":
            suggest = "opflex_server_port"
        elif key == "overlayVrfName":
            suggest = "overlay_vrf_name"
        elif key == "ovsMemoryLimit":
            suggest = "ovs_memory_limit"
        elif key == "pbrTrackingNonSnat":
            suggest = "pbr_tracking_non_snat"
        elif key == "podSubnetChunkSize":
            suggest = "pod_subnet_chunk_size"
        elif key == "runGbpContainer":
            suggest = "run_gbp_container"
        elif key == "runOpflexServerContainer":
            suggest = "run_opflex_server_container"
        elif key == "serviceMonitorInterval":
            suggest = "service_monitor_interval"
        elif key == "snatContractScope":
            suggest = "snat_contract_scope"
        elif key == "snatNamespace":
            suggest = "snat_namespace"
        elif key == "snatPortRangeEnd":
            suggest = "snat_port_range_end"
        elif key == "snatPortRangeStart":
            suggest = "snat_port_range_start"
        elif key == "snatPortsPerNode":
            suggest = "snat_ports_per_node"
        elif key == "sriovEnable":
            suggest = "sriov_enable"
        elif key == "subnetDomainName":
            suggest = "subnet_domain_name"
        elif key == "useAciAnywhereCrd":
            suggest = "use_aci_anywhere_crd"
        elif key == "useAciCniPriorityClass":
            suggest = "use_aci_cni_priority_class"
        elif key == "useClusterRole":
            suggest = "use_cluster_role"
        elif key == "useHostNetnsVolume":
            suggest = "use_host_netns_volume"
        elif key == "useOpflexServerVolume":
            suggest = "use_opflex_server_volume"
        elif key == "usePrivilegedContainer":
            suggest = "use_privileged_container"
        elif key == "vmmController":
            suggest = "vmm_controller"
        elif key == "vmmDomain":
            suggest = "vmm_domain"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@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[builtins.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[builtins.str]:
        return pulumi.get(self, "cloud_provider")


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

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


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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider(dict):
    def __init__(__self__, *,
                 password: builtins.str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> builtins.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: builtins.str,
                 roles: Sequence[builtins.str],
                 user: builtins.str,
                 docker_socket: Optional[builtins.str] = None,
                 hostname_override: Optional[builtins.str] = None,
                 internal_address: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 node_id: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None,
                 ssh_key: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.str] = None):
        """
        :param Mapping[str, builtins.str] labels: Labels for the cluster template (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

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

    @property
    @pulumi.getter
    def roles(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "roles")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[builtins.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: builtins.str,
                 ecr_credential_plugin: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin'] = None,
                 is_default: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 user: Optional[builtins.str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs' ecr_credential_plugin: ECR credential plugin config
        """
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

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

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

    @property
    @pulumi.getter
    def user(self) -> Optional[builtins.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[builtins.str] = None,
                 aws_secret_access_key: Optional[builtins.str] = None,
                 aws_session_token: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "aws_access_key_id")

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

    @property
    @pulumi.getter(name="awsSessionToken")
    def aws_session_token(self) -> Optional[builtins.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[builtins.str] = None,
                 cert: Optional[builtins.str] = None,
                 creation: Optional[builtins.str] = None,
                 external_urls: Optional[Sequence[builtins.str]] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 gid: Optional[builtins.int] = None,
                 image: Optional[builtins.str] = None,
                 key: Optional[builtins.str] = None,
                 path: Optional[builtins.str] = None,
                 retention: Optional[builtins.str] = None,
                 snapshot: Optional[builtins.bool] = None,
                 uid: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "ca_cert")

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

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

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def snapshot(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter
    def uid(self) -> Optional[builtins.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[builtins.bool] = None,
                 interval_hours: Optional[builtins.int] = None,
                 retention: Optional[builtins.int] = None,
                 s3_backup_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.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[builtins.bool]:
        """
        Enable cluster template revision. Default `true` (bool)
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def retention(self) -> Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "safe_timestamp")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.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: builtins.str,
                 endpoint: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 custom_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "bucket_name")

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

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

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

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

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

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.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 == "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['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration'] = None,
                 always_pull_images: Optional[builtins.bool] = None,
                 audit_log: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog'] = None,
                 event_rate_limit: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit'] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.str] = None,
                 secrets_encryption_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig'] = None,
                 service_cluster_ip_range: Optional[builtins.str] = None,
                 service_node_port_range: Optional[builtins.str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs' admission_configuration: Cluster admission configuration
        """
        if admission_configuration is not None:
            pulumi.set(__self__, "admission_configuration", admission_configuration)
        if always_pull_images is not None:
            pulumi.set(__self__, "always_pull_images", always_pull_images)
        if audit_log is not None:
            pulumi.set(__self__, "audit_log", audit_log)
        if event_rate_limit is not None:
            pulumi.set(__self__, "event_rate_limit", event_rate_limit)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if 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['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[builtins.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, builtins.str]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

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

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

    @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[builtins.str]:
        return pulumi.get(self, "service_cluster_ip_range")

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_version: Optional[builtins.str] = None,
                 kind: Optional[builtins.str] = None,
                 plugins: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPlugin']] = None):
        """
        :param builtins.str api_version: Admission configuration ApiVersion
        :param builtins.str kind: Admission configuration Kind
        :param Sequence['ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs'] plugins: Admission configuration plugins
        """
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if plugins is not None:
            pulumi.set(__self__, "plugins", plugins)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[builtins.str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[builtins.str]:
        """
        Admission configuration Kind
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def plugins(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPlugin']]:
        """
        Admission configuration plugins
        """
        return pulumi.get(self, "plugins")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPlugin(dict):
    def __init__(__self__, *,
                 configuration: Optional[builtins.str] = None,
                 name: Optional[builtins.str] = None,
                 path: Optional[builtins.str] = None):
        """
        :param builtins.str configuration: Plugin configuration
        :param builtins.str name: The cluster template name (string)
        :param builtins.str path: Plugin path
        """
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[builtins.str]:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog(dict):
    def __init__(__self__, *,
                 configuration: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration'] = None,
                 enabled: Optional[builtins.bool] = None):
        """
        :param builtins.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[builtins.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[builtins.str] = None,
                 max_age: Optional[builtins.int] = None,
                 max_backup: Optional[builtins.int] = None,
                 max_size: Optional[builtins.int] = None,
                 path: Optional[builtins.str] = None,
                 policy: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def policy(self) -> Optional[builtins.str]:
        return pulumi.get(self, "policy")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit(dict):
    def __init__(__self__, *,
                 configuration: Optional[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None):
        """
        :param builtins.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[builtins.str]:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.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[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None):
        """
        :param builtins.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[builtins.str]:
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.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[builtins.str] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.str] = None,
                 service_cluster_ip_range: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[builtins.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[builtins.str] = None,
                 cluster_domain: Optional[builtins.str] = None,
                 extra_args: Optional[Mapping[str, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 fail_swap_on: Optional[builtins.bool] = None,
                 generate_serving_certificate: Optional[builtins.bool] = None,
                 image: Optional[builtins.str] = None,
                 infra_container_image: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> Optional[builtins.str]:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "generate_serving_certificate")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> Optional[builtins.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, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.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, builtins.str]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.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, builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 image: Optional[builtins.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, builtins.str]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.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[builtins.bool] = None,
                 drain_input: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput'] = None,
                 max_unavailable_controlplane: Optional[builtins.str] = None,
                 max_unavailable_worker: Optional[builtins.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[builtins.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[builtins.str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[builtins.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[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 grace_period: Optional[builtins.int] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[builtins.int]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class ClusterTemplateTemplateRevisionQuestion(dict):
    def __init__(__self__, *,
                 default: builtins.str,
                 variable: builtins.str,
                 required: Optional[builtins.bool] = None,
                 type: Optional[builtins.str] = None):
        """
        :param builtins.str default: Default variable value
        :param builtins.str variable: Variable name
        :param builtins.bool required: Required variable
        :param builtins.str type: Variable type
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "variable", variable)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def default(self) -> builtins.str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> builtins.str:
        """
        Variable name
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[builtins.bool]:
        """
        Required variable
        """
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        Variable type
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ClusterV2AgentEnvVar(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str name: The name of the cluster.
        :param builtins.str value: The taint value.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        The taint value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appendTolerations":
            suggest = "append_tolerations"
        elif key == "overrideAffinity":
            suggest = "override_affinity"
        elif key == "overrideResourceRequirements":
            suggest = "override_resource_requirements"
        elif key == "schedulingCustomizations":
            suggest = "scheduling_customizations"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterAgentDeploymentCustomization. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterAgentDeploymentCustomization.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterAgentDeploymentCustomization.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 append_tolerations: Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationAppendToleration']] = None,
                 override_affinity: Optional[builtins.str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement']] = None,
                 scheduling_customizations: Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization']] = None):
        """
        :param Sequence['ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param builtins.str override_affinity: User defined affinity to override default agent affinity
        :param Sequence['ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirementArgs'] override_resource_requirements: User defined resource requirements to set on the agent
        :param Sequence['ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationArgs'] scheduling_customizations: User defined scheduling customization for the cattle cluster agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)
        if scheduling_customizations is not None:
            pulumi.set(__self__, "scheduling_customizations", scheduling_customizations)

    @property
    @pulumi.getter(name="appendTolerations")
    def append_tolerations(self) -> Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationAppendToleration']]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[builtins.str]:
        """
        User defined affinity to override default agent affinity
        """
        return pulumi.get(self, "override_affinity")

    @property
    @pulumi.getter(name="overrideResourceRequirements")
    def override_resource_requirements(self) -> Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement']]:
        """
        User defined resource requirements to set on the agent
        """
        return pulumi.get(self, "override_resource_requirements")

    @property
    @pulumi.getter(name="schedulingCustomizations")
    def scheduling_customizations(self) -> Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization']]:
        """
        User defined scheduling customization for the cattle cluster agent
        """
        return pulumi.get(self, "scheduling_customizations")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomizationAppendToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: Key is the name of the key of the item to retrieve.
        :param builtins.str effect: The taint effect. Default: `\\"NoExecute\\"`.
        :param builtins.str operator: Operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        :param builtins.int seconds: The number of seconds a pod will stay bound to a node with a matching taint.
        :param builtins.str value: The taint value.
        """
        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) -> builtins.str:
        """
        Key is the name of the key of the item to retrieve.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        """
        The taint effect. Default: `\\"NoExecute\\"`.
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        """
        Operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[builtins.int]:
        """
        The number of seconds a pod will stay bound to a node with a matching taint.
        """
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        The taint value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuLimit":
            suggest = "cpu_limit"
        elif key == "cpuRequest":
            suggest = "cpu_request"
        elif key == "memoryLimit":
            suggest = "memory_limit"
        elif key == "memoryRequest":
            suggest = "memory_request"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpu_limit: Optional[builtins.str] = None,
                 cpu_request: Optional[builtins.str] = None,
                 memory_limit: Optional[builtins.str] = None,
                 memory_request: Optional[builtins.str] = None):
        """
        :param builtins.str cpu_limit: The maximum CPU limit for agent
        :param builtins.str cpu_request: The minimum CPU required for agent
        :param builtins.str memory_limit: The maximum memory limit for agent
        :param builtins.str memory_request: The minimum memory required for agent
        """
        if cpu_limit is not None:
            pulumi.set(__self__, "cpu_limit", cpu_limit)
        if cpu_request is not None:
            pulumi.set(__self__, "cpu_request", cpu_request)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if memory_request is not None:
            pulumi.set(__self__, "memory_request", memory_request)

    @property
    @pulumi.getter(name="cpuLimit")
    def cpu_limit(self) -> Optional[builtins.str]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[builtins.str]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[builtins.str]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[builtins.str]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podDisruptionBudgets":
            suggest = "pod_disruption_budgets"
        elif key == "priorityClasses":
            suggest = "priority_classes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomization.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pod_disruption_budgets: Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget']] = None,
                 priority_classes: Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass']] = None):
        """
        :param Sequence['ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudgetArgs'] pod_disruption_budgets: The Pod Disruption Budget created for the cattle cluster agent
        :param Sequence['ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClassArgs'] priority_classes: The Priority Class created for the cattle cluster agent
        """
        if pod_disruption_budgets is not None:
            pulumi.set(__self__, "pod_disruption_budgets", pod_disruption_budgets)
        if priority_classes is not None:
            pulumi.set(__self__, "priority_classes", priority_classes)

    @property
    @pulumi.getter(name="podDisruptionBudgets")
    def pod_disruption_budgets(self) -> Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget']]:
        """
        The Pod Disruption Budget created for the cattle cluster agent
        """
        return pulumi.get(self, "pod_disruption_budgets")

    @property
    @pulumi.getter(name="priorityClasses")
    def priority_classes(self) -> Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass']]:
        """
        The Priority Class created for the cattle cluster agent
        """
        return pulumi.get(self, "priority_classes")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxUnavailable":
            suggest = "max_unavailable"
        elif key == "minAvailable":
            suggest = "min_available"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPodDisruptionBudget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_unavailable: Optional[builtins.str] = None,
                 min_available: Optional[builtins.str] = None):
        """
        :param builtins.str max_unavailable: The maximum number of cattle cluster agent replicas that can be down at a given time.
        :param builtins.str min_available: The minimum number of cattle cluster agent replicas that must be running at a given time.
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)
        if min_available is not None:
            pulumi.set(__self__, "min_available", min_available)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.str]:
        """
        The maximum number of cattle cluster agent replicas that can be down at a given time.
        """
        return pulumi.get(self, "max_unavailable")

    @property
    @pulumi.getter(name="minAvailable")
    def min_available(self) -> Optional[builtins.str]:
        """
        The minimum number of cattle cluster agent replicas that must be running at a given time.
        """
        return pulumi.get(self, "min_available")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preemptionPolicy":
            suggest = "preemption_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterAgentDeploymentCustomizationSchedulingCustomizationPriorityClass.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 value: builtins.int,
                 preemption_policy: Optional[builtins.str] = None):
        """
        :param builtins.int value: The priority value for the cattle cluster agent. Must be between negative 1 billion and 1 billion.
        :param builtins.str preemption_policy: The preemption behavior for the cattle cluster agent. Must be either 'PreemptLowerPriority' or 'Never'
        """
        pulumi.set(__self__, "value", value)
        if preemption_policy is not None:
            pulumi.set(__self__, "preemption_policy", preemption_policy)

    @property
    @pulumi.getter
    def value(self) -> builtins.int:
        """
        The priority value for the cattle cluster agent. Must be between negative 1 billion and 1 billion.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter(name="preemptionPolicy")
    def preemption_policy(self) -> Optional[builtins.str]:
        """
        The preemption behavior for the cattle cluster agent. Must be either 'PreemptLowerPriority' or 'Never'
        """
        return pulumi.get(self, "preemption_policy")


@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, builtins.str]] = None,
                 cluster_id: Optional[builtins.str] = None,
                 command: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 insecure_command: Optional[builtins.str] = None,
                 insecure_node_command: Optional[builtins.str] = None,
                 insecure_windows_node_command: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 manifest_url: Optional[builtins.str] = None,
                 name: Optional[builtins.str] = None,
                 node_command: Optional[builtins.str] = None,
                 token: Optional[builtins.str] = None,
                 windows_node_command: Optional[builtins.str] = None):
        """
        :param Mapping[str, builtins.str] annotations: Annotations for the Cluster.
        :param builtins.str cluster_id: Cluster ID.
        :param builtins.str command: Command to execute in an imported k8s cluster.
        :param builtins.str id: (Computed, string) The ID of the resource.
        :param builtins.str insecure_command: Insecure command to execute in an imported k8s cluster.
        :param builtins.str insecure_node_command: Insecure node command to execute in an imported k8s cluster.
        :param builtins.str insecure_windows_node_command: Insecure windows command to execute in an imported k8s cluster.
        :param Mapping[str, builtins.str] labels: Labels for the Cluster.
        :param builtins.str manifest_url: K8s manifest url to execute with `kubectl` to import an existing k8s cluster.
        :param builtins.str name: The name of the cluster.
        :param builtins.str node_command: Node command to execute in Linux nodes for custom k8s cluster.
        :param builtins.str token: Token for cluster registration token object.
        :param builtins.str windows_node_command: Node command to execute in Windows nodes for custom k8s cluster.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if command is not None:
            pulumi.set(__self__, "command", command)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if insecure_command is not None:
            pulumi.set(__self__, "insecure_command", insecure_command)
        if insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if manifest_url is not None:
            pulumi.set(__self__, "manifest_url", manifest_url)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_command is not None:
            pulumi.set(__self__, "node_command", node_command)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if windows_node_command is not None:
            pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Annotations for the Cluster.
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[builtins.str]:
        """
        Cluster ID.
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> Optional[builtins.str]:
        """
        Command to execute in an imported k8s cluster.
        """
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def id(self) -> Optional[builtins.str]:
        """
        (Computed, string) The ID of the resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> Optional[builtins.str]:
        """
        Insecure command to execute in an imported k8s cluster.
        """
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter(name="insecureNodeCommand")
    def insecure_node_command(self) -> Optional[builtins.str]:
        """
        Insecure node command to execute in an imported k8s cluster.
        """
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> Optional[builtins.str]:
        """
        Insecure windows command to execute in an imported k8s cluster.
        """
        return pulumi.get(self, "insecure_windows_node_command")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Labels for the Cluster.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> Optional[builtins.str]:
        """
        K8s manifest url to execute with `kubectl` to import an existing k8s cluster.
        """
        return pulumi.get(self, "manifest_url")

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> Optional[builtins.str]:
        """
        Node command to execute in Linux nodes for custom k8s cluster.
        """
        return pulumi.get(self, "node_command")

    @property
    @pulumi.getter
    def token(self) -> Optional[builtins.str]:
        """
        Token for cluster registration token object.
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> Optional[builtins.str]:
        """
        Node command to execute in Windows nodes for custom k8s cluster.
        """
        return pulumi.get(self, "windows_node_command")


@pulumi.output_type
class ClusterV2FleetAgentDeploymentCustomization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appendTolerations":
            suggest = "append_tolerations"
        elif key == "overrideAffinity":
            suggest = "override_affinity"
        elif key == "overrideResourceRequirements":
            suggest = "override_resource_requirements"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2FleetAgentDeploymentCustomization. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2FleetAgentDeploymentCustomization.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2FleetAgentDeploymentCustomization.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 append_tolerations: Optional[Sequence['outputs.ClusterV2FleetAgentDeploymentCustomizationAppendToleration']] = None,
                 override_affinity: Optional[builtins.str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement']] = None):
        """
        :param Sequence['ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param builtins.str override_affinity: User defined affinity to override default agent affinity
        :param Sequence['ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirementArgs'] override_resource_requirements: User defined resource requirements to set on the agent
        """
        if append_tolerations is not None:
            pulumi.set(__self__, "append_tolerations", append_tolerations)
        if override_affinity is not None:
            pulumi.set(__self__, "override_affinity", override_affinity)
        if override_resource_requirements is not None:
            pulumi.set(__self__, "override_resource_requirements", override_resource_requirements)

    @property
    @pulumi.getter(name="appendTolerations")
    def append_tolerations(self) -> Optional[Sequence['outputs.ClusterV2FleetAgentDeploymentCustomizationAppendToleration']]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[builtins.str]:
        """
        User defined affinity to override default agent affinity
        """
        return pulumi.get(self, "override_affinity")

    @property
    @pulumi.getter(name="overrideResourceRequirements")
    def override_resource_requirements(self) -> Optional[Sequence['outputs.ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement']]:
        """
        User defined resource requirements to set on the agent
        """
        return pulumi.get(self, "override_resource_requirements")


@pulumi.output_type
class ClusterV2FleetAgentDeploymentCustomizationAppendToleration(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 seconds: Optional[builtins.int] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: Key is the name of the key of the item to retrieve.
        :param builtins.str effect: The taint effect. Default: `\\"NoExecute\\"`.
        :param builtins.str operator: Operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        :param builtins.int seconds: The number of seconds a pod will stay bound to a node with a matching taint.
        :param builtins.str value: The taint value.
        """
        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) -> builtins.str:
        """
        Key is the name of the key of the item to retrieve.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        """
        The taint effect. Default: `\\"NoExecute\\"`.
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        """
        Operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[builtins.int]:
        """
        The number of seconds a pod will stay bound to a node with a matching taint.
        """
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        The taint value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuLimit":
            suggest = "cpu_limit"
        elif key == "cpuRequest":
            suggest = "cpu_request"
        elif key == "memoryLimit":
            suggest = "memory_limit"
        elif key == "memoryRequest":
            suggest = "memory_request"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpu_limit: Optional[builtins.str] = None,
                 cpu_request: Optional[builtins.str] = None,
                 memory_limit: Optional[builtins.str] = None,
                 memory_request: Optional[builtins.str] = None):
        """
        :param builtins.str cpu_limit: The maximum CPU limit for agent
        :param builtins.str cpu_request: The minimum CPU required for agent
        :param builtins.str memory_limit: The maximum memory limit for agent
        :param builtins.str memory_request: The minimum memory required for agent
        """
        if cpu_limit is not None:
            pulumi.set(__self__, "cpu_limit", cpu_limit)
        if cpu_request is not None:
            pulumi.set(__self__, "cpu_request", cpu_request)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if memory_request is not None:
            pulumi.set(__self__, "memory_request", memory_request)

    @property
    @pulumi.getter(name="cpuLimit")
    def cpu_limit(self) -> Optional[builtins.str]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[builtins.str]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[builtins.str]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[builtins.str]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")


@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[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.str] = None):
        """
        :param builtins.str ca_certs: CA certs for the authorized cluster endpoint. It is only needed if there is a load balancer in front of the downstream cluster that is using an untrusted certificate. If you have a valid certificate, then nothing needs to be added to the CA Certificates field.
        :param builtins.bool enabled: If `enabled` is set to true, nodes will be drained before upgrade.
        :param builtins.str fqdn: FQDN for the authorized cluster endpoint. If one is entered, it should point to the downstream cluster.
        """
        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[builtins.str]:
        """
        CA certs for the authorized cluster endpoint. It is only needed if there is a load balancer in front of the downstream cluster that is using an untrusted certificate. If you have a valid certificate, then nothing needs to be added to the CA Certificates field.
        """
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        If `enabled` is set to true, nodes will be drained before upgrade.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[builtins.str]:
        """
        FQDN for the authorized cluster endpoint. If one is entered, it should point to the downstream cluster.
        """
        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 == "etcdSnapshotCreate":
            suggest = "etcd_snapshot_create"
        elif key == "etcdSnapshotRestore":
            suggest = "etcd_snapshot_restore"
        elif key == "localAuthEndpoint":
            suggest = "local_auth_endpoint"
        elif key == "machineGlobalConfig":
            suggest = "machine_global_config"
        elif key == "machinePoolDefaults":
            suggest = "machine_pool_defaults"
        elif key == "machinePools":
            suggest = "machine_pools"
        elif key == "machineSelectorConfigs":
            suggest = "machine_selector_configs"
        elif key == "machineSelectorFiles":
            suggest = "machine_selector_files"
        elif key == "rotateCertificates":
            suggest = "rotate_certificates"
        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[builtins.str] = None,
                 chart_values: Optional[builtins.str] = None,
                 etcd: Optional['outputs.ClusterV2RkeConfigEtcd'] = None,
                 etcd_snapshot_create: Optional['outputs.ClusterV2RkeConfigEtcdSnapshotCreate'] = None,
                 etcd_snapshot_restore: Optional['outputs.ClusterV2RkeConfigEtcdSnapshotRestore'] = None,
                 local_auth_endpoint: Optional['outputs.ClusterV2RkeConfigLocalAuthEndpoint'] = None,
                 machine_global_config: Optional[builtins.str] = None,
                 machine_pool_defaults: Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolDefault']] = None,
                 machine_pools: Optional[Sequence['outputs.ClusterV2RkeConfigMachinePool']] = None,
                 machine_selector_configs: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorConfig']] = None,
                 machine_selector_files: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFile']] = None,
                 registries: Optional['outputs.ClusterV2RkeConfigRegistries'] = None,
                 rotate_certificates: Optional['outputs.ClusterV2RkeConfigRotateCertificates'] = None,
                 upgrade_strategy: Optional['outputs.ClusterV2RkeConfigUpgradeStrategy'] = None):
        """
        :param builtins.str additional_manifest: Cluster V2 additional manifest
        :param builtins.str chart_values: Cluster V2 chart values. It should be in YAML format
        :param 'ClusterV2RkeConfigEtcdArgs' etcd: Cluster V2 etcd
        :param 'ClusterV2RkeConfigEtcdSnapshotCreateArgs' etcd_snapshot_create: Cluster V2 etcd snapshot create
        :param 'ClusterV2RkeConfigEtcdSnapshotRestoreArgs' etcd_snapshot_restore: Cluster V2 etcd snapshot restore
        :param 'ClusterV2RkeConfigLocalAuthEndpointArgs' local_auth_endpoint: Local auth endpoint configures the Authorized Cluster Endpoint (ACE) which can be used to directly access the Kubernetes API server, without requiring communication through Rancher. For more information, please refer to [Rancher Documentation](https://ranchermanager.docs.rancher.com/how-to-guides/new-user-guides/kubernetes-clusters-in-rancher-setup/register-existing-clusters#authorized-cluster-endpoint-support-for-rke2-and-k3s-clusters).
        :param builtins.str machine_global_config: Cluster V2 machine global config
        :param Sequence['ClusterV2RkeConfigMachinePoolDefaultArgs'] machine_pool_defaults: Default values for machine pool configurations if unset
        :param Sequence['ClusterV2RkeConfigMachinePoolArgs'] machine_pools: Cluster V2 machine pools
        :param Sequence['ClusterV2RkeConfigMachineSelectorConfigArgs'] machine_selector_configs: Cluster V2 machine selector config
        :param Sequence['ClusterV2RkeConfigMachineSelectorFileArgs'] machine_selector_files: Cluster V2 machine selector files
        :param 'ClusterV2RkeConfigRegistriesArgs' registries: Cluster V2 registries
        :param 'ClusterV2RkeConfigRotateCertificatesArgs' rotate_certificates: Cluster V2 certificate rotation
        :param 'ClusterV2RkeConfigUpgradeStrategyArgs' upgrade_strategy: Cluster V2 upgrade strategy
        """
        if additional_manifest is not None:
            pulumi.set(__self__, "additional_manifest", additional_manifest)
        if chart_values is not None:
            pulumi.set(__self__, "chart_values", chart_values)
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if etcd_snapshot_create is not None:
            pulumi.set(__self__, "etcd_snapshot_create", etcd_snapshot_create)
        if etcd_snapshot_restore is not None:
            pulumi.set(__self__, "etcd_snapshot_restore", etcd_snapshot_restore)
        if local_auth_endpoint is not None:
            pulumi.set(__self__, "local_auth_endpoint", local_auth_endpoint)
        if machine_global_config is not None:
            pulumi.set(__self__, "machine_global_config", machine_global_config)
        if machine_pool_defaults is not None:
            pulumi.set(__self__, "machine_pool_defaults", machine_pool_defaults)
        if machine_pools is not None:
            pulumi.set(__self__, "machine_pools", machine_pools)
        if machine_selector_configs is not None:
            pulumi.set(__self__, "machine_selector_configs", machine_selector_configs)
        if machine_selector_files is not None:
            pulumi.set(__self__, "machine_selector_files", machine_selector_files)
        if registries is not None:
            pulumi.set(__self__, "registries", registries)
        if rotate_certificates is not None:
            pulumi.set(__self__, "rotate_certificates", rotate_certificates)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter(name="additionalManifest")
    def additional_manifest(self) -> Optional[builtins.str]:
        """
        Cluster V2 additional manifest
        """
        return pulumi.get(self, "additional_manifest")

    @property
    @pulumi.getter(name="chartValues")
    def chart_values(self) -> Optional[builtins.str]:
        """
        Cluster V2 chart values. It should be in YAML format
        """
        return pulumi.get(self, "chart_values")

    @property
    @pulumi.getter
    def etcd(self) -> Optional['outputs.ClusterV2RkeConfigEtcd']:
        """
        Cluster V2 etcd
        """
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="etcdSnapshotCreate")
    def etcd_snapshot_create(self) -> Optional['outputs.ClusterV2RkeConfigEtcdSnapshotCreate']:
        """
        Cluster V2 etcd snapshot create
        """
        return pulumi.get(self, "etcd_snapshot_create")

    @property
    @pulumi.getter(name="etcdSnapshotRestore")
    def etcd_snapshot_restore(self) -> Optional['outputs.ClusterV2RkeConfigEtcdSnapshotRestore']:
        """
        Cluster V2 etcd snapshot restore
        """
        return pulumi.get(self, "etcd_snapshot_restore")

    @property
    @pulumi.getter(name="localAuthEndpoint")
    @_utilities.deprecated("""Use rancher2_cluster_v2.local_auth_endpoint instead""")
    def local_auth_endpoint(self) -> Optional['outputs.ClusterV2RkeConfigLocalAuthEndpoint']:
        """
        Local auth endpoint configures the Authorized Cluster Endpoint (ACE) which can be used to directly access the Kubernetes API server, without requiring communication through Rancher. For more information, please refer to [Rancher Documentation](https://ranchermanager.docs.rancher.com/how-to-guides/new-user-guides/kubernetes-clusters-in-rancher-setup/register-existing-clusters#authorized-cluster-endpoint-support-for-rke2-and-k3s-clusters).
        """
        return pulumi.get(self, "local_auth_endpoint")

    @property
    @pulumi.getter(name="machineGlobalConfig")
    def machine_global_config(self) -> Optional[builtins.str]:
        """
        Cluster V2 machine global config
        """
        return pulumi.get(self, "machine_global_config")

    @property
    @pulumi.getter(name="machinePoolDefaults")
    def machine_pool_defaults(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolDefault']]:
        """
        Default values for machine pool configurations if unset
        """
        return pulumi.get(self, "machine_pool_defaults")

    @property
    @pulumi.getter(name="machinePools")
    def machine_pools(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachinePool']]:
        """
        Cluster V2 machine pools
        """
        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
        """
        return pulumi.get(self, "machine_selector_configs")

    @property
    @pulumi.getter(name="machineSelectorFiles")
    def machine_selector_files(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFile']]:
        """
        Cluster V2 machine selector files
        """
        return pulumi.get(self, "machine_selector_files")

    @property
    @pulumi.getter
    def registries(self) -> Optional['outputs.ClusterV2RkeConfigRegistries']:
        """
        Cluster V2 registries
        """
        return pulumi.get(self, "registries")

    @property
    @pulumi.getter(name="rotateCertificates")
    def rotate_certificates(self) -> Optional['outputs.ClusterV2RkeConfigRotateCertificates']:
        """
        Cluster V2 certificate rotation
        """
        return pulumi.get(self, "rotate_certificates")

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional['outputs.ClusterV2RkeConfigUpgradeStrategy']:
        """
        Cluster V2 upgrade strategy
        """
        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[builtins.bool] = None,
                 s3_config: Optional['outputs.ClusterV2RkeConfigEtcdS3Config'] = None,
                 snapshot_retention: Optional[builtins.int] = None,
                 snapshot_schedule_cron: Optional[builtins.str] = None):
        """
        :param builtins.bool disable_snapshots: Disable ETCD snapshots
        :param 'ClusterV2RkeConfigEtcdS3ConfigArgs' s3_config: ETCD snapshot S3 config
        :param builtins.int snapshot_retention: ETCD snapshot retention
        :param builtins.str snapshot_schedule_cron: ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        if disable_snapshots is not None:
            pulumi.set(__self__, "disable_snapshots", disable_snapshots)
        if s3_config is not None:
            pulumi.set(__self__, "s3_config", s3_config)
        if snapshot_retention is not None:
            pulumi.set(__self__, "snapshot_retention", snapshot_retention)
        if snapshot_schedule_cron is not None:
            pulumi.set(__self__, "snapshot_schedule_cron", snapshot_schedule_cron)

    @property
    @pulumi.getter(name="disableSnapshots")
    def disable_snapshots(self) -> Optional[builtins.bool]:
        """
        Disable ETCD snapshots
        """
        return pulumi.get(self, "disable_snapshots")

    @property
    @pulumi.getter(name="s3Config")
    def s3_config(self) -> Optional['outputs.ClusterV2RkeConfigEtcdS3Config']:
        """
        ETCD snapshot S3 config
        """
        return pulumi.get(self, "s3_config")

    @property
    @pulumi.getter(name="snapshotRetention")
    def snapshot_retention(self) -> Optional[builtins.int]:
        """
        ETCD snapshot retention
        """
        return pulumi.get(self, "snapshot_retention")

    @property
    @pulumi.getter(name="snapshotScheduleCron")
    def snapshot_schedule_cron(self) -> Optional[builtins.str]:
        """
        ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        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: builtins.str,
                 endpoint: builtins.str,
                 cloud_credential_name: Optional[builtins.str] = None,
                 endpoint_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 skip_ssl_verify: Optional[builtins.bool] = None):
        """
        :param builtins.str bucket: ETCD snapshot S3 bucket
        :param builtins.str endpoint: ETCD snapshot S3 endpoint
        :param builtins.str cloud_credential_name: ETCD snapshot S3 cloud credential name
        :param builtins.str endpoint_ca: ETCD snapshot S3 endpoint CA
        :param builtins.str folder: ETCD snapshot S3 folder
        :param builtins.str region: ETCD snapshot S3 region
        :param builtins.bool skip_ssl_verify: Disable ETCD skip ssl verify
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "endpoint", endpoint)
        if cloud_credential_name is not None:
            pulumi.set(__self__, "cloud_credential_name", cloud_credential_name)
        if endpoint_ca is not None:
            pulumi.set(__self__, "endpoint_ca", endpoint_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if skip_ssl_verify is not None:
            pulumi.set(__self__, "skip_ssl_verify", skip_ssl_verify)

    @property
    @pulumi.getter
    def bucket(self) -> builtins.str:
        """
        ETCD snapshot S3 bucket
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def endpoint(self) -> builtins.str:
        """
        ETCD snapshot S3 endpoint
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="cloudCredentialName")
    def cloud_credential_name(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 cloud credential name
        """
        return pulumi.get(self, "cloud_credential_name")

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 endpoint CA
        """
        return pulumi.get(self, "endpoint_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 folder
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[builtins.bool]:
        """
        Disable ETCD skip ssl verify
        """
        return pulumi.get(self, "skip_ssl_verify")


@pulumi.output_type
class ClusterV2RkeConfigEtcdSnapshotCreate(dict):
    def __init__(__self__, *,
                 generation: builtins.int):
        """
        :param builtins.int generation: ETCD generation to initiate a snapshot
        """
        pulumi.set(__self__, "generation", generation)

    @property
    @pulumi.getter
    def generation(self) -> builtins.int:
        """
        ETCD generation to initiate a snapshot
        """
        return pulumi.get(self, "generation")


@pulumi.output_type
class ClusterV2RkeConfigEtcdSnapshotRestore(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "restoreRkeConfig":
            suggest = "restore_rke_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigEtcdSnapshotRestore. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigEtcdSnapshotRestore.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigEtcdSnapshotRestore.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 generation: builtins.int,
                 name: builtins.str,
                 restore_rke_config: Optional[builtins.str] = None):
        """
        :param builtins.int generation: ETCD snapshot desired generation
        :param builtins.str name: The name of the cluster.
        :param builtins.str restore_rke_config: ETCD restore RKE config (set to none, all, or kubernetesVersion)
        """
        pulumi.set(__self__, "generation", generation)
        pulumi.set(__self__, "name", name)
        if restore_rke_config is not None:
            pulumi.set(__self__, "restore_rke_config", restore_rke_config)

    @property
    @pulumi.getter
    def generation(self) -> builtins.int:
        """
        ETCD snapshot desired generation
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="restoreRkeConfig")
    def restore_rke_config(self) -> Optional[builtins.str]:
        """
        ETCD restore RKE config (set to none, all, or kubernetesVersion)
        """
        return pulumi.get(self, "restore_rke_config")


@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[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.str] = None):
        """
        :param builtins.str ca_certs: CA certs for the authorized cluster endpoint. It is only needed if there is a load balancer in front of the downstream cluster that is using an untrusted certificate. If you have a valid certificate, then nothing needs to be added to the CA Certificates field.
        :param builtins.bool enabled: If `enabled` is set to true, nodes will be drained before upgrade.
        :param builtins.str fqdn: FQDN for the authorized cluster endpoint. If one is entered, it should point to the downstream cluster.
        """
        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[builtins.str]:
        """
        CA certs for the authorized cluster endpoint. It is only needed if there is a load balancer in front of the downstream cluster that is using an untrusted certificate. If you have a valid certificate, then nothing needs to be added to the CA Certificates field.
        """
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        If `enabled` is set to true, nodes will be drained before upgrade.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[builtins.str]:
        """
        FQDN for the authorized cluster endpoint. If one is entered, it should point to the downstream cluster.
        """
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class ClusterV2RkeConfigMachinePool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "machineConfig":
            suggest = "machine_config"
        elif key == "cloudCredentialSecretName":
            suggest = "cloud_credential_secret_name"
        elif key == "controlPlaneRole":
            suggest = "control_plane_role"
        elif key == "drainBeforeDelete":
            suggest = "drain_before_delete"
        elif key == "etcdRole":
            suggest = "etcd_role"
        elif key == "hostnameLengthLimit":
            suggest = "hostname_length_limit"
        elif key == "machineLabels":
            suggest = "machine_labels"
        elif key == "maxUnhealthy":
            suggest = "max_unhealthy"
        elif key == "nodeDrainTimeout":
            suggest = "node_drain_timeout"
        elif key == "nodeStartupTimeoutSeconds":
            suggest = "node_startup_timeout_seconds"
        elif key == "rollingUpdate":
            suggest = "rolling_update"
        elif key == "unhealthyNodeTimeoutSeconds":
            suggest = "unhealthy_node_timeout_seconds"
        elif key == "unhealthyRange":
            suggest = "unhealthy_range"
        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__, *,
                 machine_config: 'outputs.ClusterV2RkeConfigMachinePoolMachineConfig',
                 name: builtins.str,
                 annotations: Optional[Mapping[str, builtins.str]] = None,
                 cloud_credential_secret_name: Optional[builtins.str] = None,
                 control_plane_role: Optional[builtins.bool] = None,
                 drain_before_delete: Optional[builtins.bool] = None,
                 etcd_role: Optional[builtins.bool] = None,
                 hostname_length_limit: Optional[builtins.int] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 machine_labels: Optional[Mapping[str, builtins.str]] = None,
                 max_unhealthy: Optional[builtins.str] = None,
                 node_drain_timeout: Optional[builtins.int] = None,
                 node_startup_timeout_seconds: Optional[builtins.int] = None,
                 paused: Optional[builtins.bool] = None,
                 quantity: Optional[builtins.int] = None,
                 rolling_update: Optional['outputs.ClusterV2RkeConfigMachinePoolRollingUpdate'] = None,
                 taints: Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolTaint']] = None,
                 unhealthy_node_timeout_seconds: Optional[builtins.int] = None,
                 unhealthy_range: Optional[builtins.str] = None,
                 worker_role: Optional[builtins.bool] = None):
        """
        :param 'ClusterV2RkeConfigMachinePoolMachineConfigArgs' machine_config: Machine config data
        :param builtins.str name: The name of the cluster.
        :param Mapping[str, builtins.str] annotations: Annotations for the Cluster.
        :param builtins.str cloud_credential_secret_name: Cloud credential secret name is the secret to be used when a cloud credential secret name is not specified at the machine pool level.
        :param builtins.bool control_plane_role: Machine pool control plane role
        :param builtins.bool drain_before_delete: Machine pool drain before delete
        :param builtins.bool etcd_role: Machine pool etcd role
        :param builtins.int hostname_length_limit: maximum length for autogenerated hostname
        :param Mapping[str, builtins.str] labels: Labels for the Cluster.
        :param Mapping[str, builtins.str] machine_labels: Labels of the machine
        :param builtins.str max_unhealthy: max unhealthy nodes for automated replacement to be allowed
        :param builtins.int node_drain_timeout: seconds to wait for machine pool drain to complete before machine deletion
        :param builtins.int node_startup_timeout_seconds: seconds a new node has to become active before it is replaced
        :param builtins.bool paused: Machine pool paused
        :param builtins.int quantity: Machine pool quantity
        :param 'ClusterV2RkeConfigMachinePoolRollingUpdateArgs' rolling_update: Machine pool rolling update
        :param Sequence['ClusterV2RkeConfigMachinePoolTaintArgs'] taints: Machine pool taints
        :param builtins.int unhealthy_node_timeout_seconds: seconds an unhealthy node has to become active before it is replaced
        :param builtins.str unhealthy_range: range of unhealthy nodes for automated replacement to be allowed
        :param builtins.bool worker_role: Machine pool worker role
        """
        pulumi.set(__self__, "machine_config", machine_config)
        pulumi.set(__self__, "name", name)
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cloud_credential_secret_name is not None:
            pulumi.set(__self__, "cloud_credential_secret_name", cloud_credential_secret_name)
        if control_plane_role is not None:
            pulumi.set(__self__, "control_plane_role", control_plane_role)
        if drain_before_delete is not None:
            pulumi.set(__self__, "drain_before_delete", drain_before_delete)
        if etcd_role is not None:
            pulumi.set(__self__, "etcd_role", etcd_role)
        if hostname_length_limit is not None:
            pulumi.set(__self__, "hostname_length_limit", hostname_length_limit)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if machine_labels is not None:
            pulumi.set(__self__, "machine_labels", machine_labels)
        if max_unhealthy is not None:
            pulumi.set(__self__, "max_unhealthy", max_unhealthy)
        if node_drain_timeout is not None:
            pulumi.set(__self__, "node_drain_timeout", node_drain_timeout)
        if node_startup_timeout_seconds is not None:
            pulumi.set(__self__, "node_startup_timeout_seconds", node_startup_timeout_seconds)
        if paused is not None:
            pulumi.set(__self__, "paused", paused)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if unhealthy_node_timeout_seconds is not None:
            pulumi.set(__self__, "unhealthy_node_timeout_seconds", unhealthy_node_timeout_seconds)
        if unhealthy_range is not None:
            pulumi.set(__self__, "unhealthy_range", unhealthy_range)
        if worker_role is not None:
            pulumi.set(__self__, "worker_role", worker_role)

    @property
    @pulumi.getter(name="machineConfig")
    def machine_config(self) -> 'outputs.ClusterV2RkeConfigMachinePoolMachineConfig':
        """
        Machine config data
        """
        return pulumi.get(self, "machine_config")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Annotations for the Cluster.
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="cloudCredentialSecretName")
    def cloud_credential_secret_name(self) -> Optional[builtins.str]:
        """
        Cloud credential secret name is the secret to be used when a cloud credential secret name is not specified at the machine pool level.
        """
        return pulumi.get(self, "cloud_credential_secret_name")

    @property
    @pulumi.getter(name="controlPlaneRole")
    def control_plane_role(self) -> Optional[builtins.bool]:
        """
        Machine pool control plane role
        """
        return pulumi.get(self, "control_plane_role")

    @property
    @pulumi.getter(name="drainBeforeDelete")
    def drain_before_delete(self) -> Optional[builtins.bool]:
        """
        Machine pool drain before delete
        """
        return pulumi.get(self, "drain_before_delete")

    @property
    @pulumi.getter(name="etcdRole")
    def etcd_role(self) -> Optional[builtins.bool]:
        """
        Machine pool etcd role
        """
        return pulumi.get(self, "etcd_role")

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[builtins.int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Labels for the Cluster.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="machineLabels")
    def machine_labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Labels of the machine
        """
        return pulumi.get(self, "machine_labels")

    @property
    @pulumi.getter(name="maxUnhealthy")
    def max_unhealthy(self) -> Optional[builtins.str]:
        """
        max unhealthy nodes for automated replacement to be allowed
        """
        return pulumi.get(self, "max_unhealthy")

    @property
    @pulumi.getter(name="nodeDrainTimeout")
    def node_drain_timeout(self) -> Optional[builtins.int]:
        """
        seconds to wait for machine pool drain to complete before machine deletion
        """
        return pulumi.get(self, "node_drain_timeout")

    @property
    @pulumi.getter(name="nodeStartupTimeoutSeconds")
    def node_startup_timeout_seconds(self) -> Optional[builtins.int]:
        """
        seconds a new node has to become active before it is replaced
        """
        return pulumi.get(self, "node_startup_timeout_seconds")

    @property
    @pulumi.getter
    def paused(self) -> Optional[builtins.bool]:
        """
        Machine pool paused
        """
        return pulumi.get(self, "paused")

    @property
    @pulumi.getter
    def quantity(self) -> Optional[builtins.int]:
        """
        Machine pool quantity
        """
        return pulumi.get(self, "quantity")

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.ClusterV2RkeConfigMachinePoolRollingUpdate']:
        """
        Machine pool rolling update
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolTaint']]:
        """
        Machine pool taints
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="unhealthyNodeTimeoutSeconds")
    def unhealthy_node_timeout_seconds(self) -> Optional[builtins.int]:
        """
        seconds an unhealthy node has to become active before it is replaced
        """
        return pulumi.get(self, "unhealthy_node_timeout_seconds")

    @property
    @pulumi.getter(name="unhealthyRange")
    def unhealthy_range(self) -> Optional[builtins.str]:
        """
        range of unhealthy nodes for automated replacement to be allowed
        """
        return pulumi.get(self, "unhealthy_range")

    @property
    @pulumi.getter(name="workerRole")
    def worker_role(self) -> Optional[builtins.bool]:
        """
        Machine pool worker role
        """
        return pulumi.get(self, "worker_role")


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolDefault(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostnameLengthLimit":
            suggest = "hostname_length_limit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachinePoolDefault. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachinePoolDefault.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachinePoolDefault.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hostname_length_limit: Optional[builtins.int] = None):
        """
        :param builtins.int hostname_length_limit: maximum length for autogenerated hostname
        """
        if hostname_length_limit is not None:
            pulumi.set(__self__, "hostname_length_limit", hostname_length_limit)

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[builtins.int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolMachineConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachinePoolMachineConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachinePoolMachineConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachinePoolMachineConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kind: builtins.str,
                 name: builtins.str,
                 api_version: Optional[builtins.str] = None):
        """
        :param builtins.str kind: Machine config kind
        :param builtins.str name: The name of the cluster.
        :param builtins.str api_version: Machine config API version
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "name", name)
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)

    @property
    @pulumi.getter
    def kind(self) -> builtins.str:
        """
        Machine config kind
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[builtins.str]:
        """
        Machine config API version
        """
        return pulumi.get(self, "api_version")


@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[builtins.str] = None,
                 max_unavailable: Optional[builtins.str] = None):
        """
        :param builtins.str max_surge: Rolling update max surge
        :param builtins.str max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.str]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.str]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolTaint(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str,
                 effect: Optional[builtins.str] = None):
        """
        :param builtins.str key: Key is the name of the key of the item to retrieve.
        :param builtins.str value: The taint value.
        :param builtins.str effect: The taint effect. Default: `\\"NoExecute\\"`.
        """
        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) -> builtins.str:
        """
        Key is the name of the key of the item to retrieve.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        The taint value.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        """
        The taint effect. Default: `\\"NoExecute\\"`.
        """
        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[builtins.str] = None,
                 machine_label_selector: Optional['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector'] = None):
        """
        :param builtins.str config: Machine selector config
        :param 'ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs' machine_label_selector: Machine label selector
        """
        if config is not None:
            pulumi.set(__self__, "config", config)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

    @property
    @pulumi.getter
    def config(self) -> Optional[builtins.str]:
        """
        Machine selector config
        """
        return pulumi.get(self, "config")

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector']:
        """
        Machine label selector
        """
        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, builtins.str]] = None):
        """
        :param Sequence['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, builtins.str] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression']]:
        """
        Label selector match expressions
        """
        return pulumi.get(self, "match_expressions")

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 values: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.str key: Label selector requirement key
        :param builtins.str operator: Label selector operator
        :param Sequence[builtins.str] values: Label selector requirement values
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[builtins.str]]:
        """
        Label selector requirement values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fileSources":
            suggest = "file_sources"
        elif key == "machineLabelSelector":
            suggest = "machine_label_selector"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachineSelectorFile. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachineSelectorFile.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachineSelectorFile.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 file_sources: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSource']] = None,
                 machine_label_selector: Optional['outputs.ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector'] = None):
        """
        :param Sequence['ClusterV2RkeConfigMachineSelectorFileFileSourceArgs'] file_sources: File sources
        :param 'ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs' machine_label_selector: Machine label selector
        """
        if file_sources is not None:
            pulumi.set(__self__, "file_sources", file_sources)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

    @property
    @pulumi.getter(name="fileSources")
    def file_sources(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSource']]:
        """
        File sources
        """
        return pulumi.get(self, "file_sources")

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional['outputs.ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector']:
        """
        Machine label selector
        """
        return pulumi.get(self, "machine_label_selector")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileFileSource(dict):
    def __init__(__self__, *,
                 configmap: Optional['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap'] = None,
                 secret: Optional['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceSecret'] = None):
        """
        :param 'ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs' configmap: The configmap which is the source of files
        :param 'ClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs' secret: The secret which is the source of files
        """
        if configmap is not None:
            pulumi.set(__self__, "configmap", configmap)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def configmap(self) -> Optional['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap']:
        """
        The configmap which is the source of files
        """
        return pulumi.get(self, "configmap")

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceSecret']:
        """
        The secret which is the source of files
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultPermissions":
            suggest = "default_permissions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmap.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: builtins.str,
                 default_permissions: Optional[builtins.str] = None,
                 items: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItem']] = None):
        """
        :param builtins.str name: The name of the cluster.
        :param builtins.str default_permissions: The default permissions to be applied when they are not set at the item level
        :param Sequence['ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs'] items: Items(files) to retrieve from the K8s object
        """
        pulumi.set(__self__, "name", name)
        if default_permissions is not None:
            pulumi.set(__self__, "default_permissions", default_permissions)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[builtins.str]:
        """
        The default permissions to be applied when they are not set at the item level
        """
        return pulumi.get(self, "default_permissions")

    @property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItem']]:
        """
        Items(files) to retrieve from the K8s object
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItem(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 path: builtins.str,
                 dynamic: Optional[builtins.bool] = None,
                 hash: Optional[builtins.str] = None,
                 permissions: Optional[builtins.str] = None):
        """
        :param builtins.str key: The key of the item(file) to retrieve
        :param builtins.str path: The path to put the file in the target node
        :param builtins.bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param builtins.str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param builtins.str permissions: The numeric representation of the file permissions
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        if dynamic is not None:
            pulumi.set(__self__, "dynamic", dynamic)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[builtins.bool]:
        """
        If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        """
        return pulumi.get(self, "dynamic")

    @property
    @pulumi.getter
    def hash(self) -> Optional[builtins.str]:
        """
        The base64 encoded value of the SHA256 checksum of the file's content
        """
        return pulumi.get(self, "hash")

    @property
    @pulumi.getter
    def permissions(self) -> Optional[builtins.str]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultPermissions":
            suggest = "default_permissions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigMachineSelectorFileFileSourceSecret. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachineSelectorFileFileSourceSecret.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachineSelectorFileFileSourceSecret.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: builtins.str,
                 default_permissions: Optional[builtins.str] = None,
                 items: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItem']] = None):
        """
        :param builtins.str name: The name of the cluster.
        :param builtins.str default_permissions: The default permissions to be applied when they are not set at the item level
        :param Sequence['ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs'] items: Items(files) to retrieve from the K8s object
        """
        pulumi.set(__self__, "name", name)
        if default_permissions is not None:
            pulumi.set(__self__, "default_permissions", default_permissions)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[builtins.str]:
        """
        The default permissions to be applied when they are not set at the item level
        """
        return pulumi.get(self, "default_permissions")

    @property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItem']]:
        """
        Items(files) to retrieve from the K8s object
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItem(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 path: builtins.str,
                 dynamic: Optional[builtins.bool] = None,
                 hash: Optional[builtins.str] = None,
                 permissions: Optional[builtins.str] = None):
        """
        :param builtins.str key: The key of the item(file) to retrieve
        :param builtins.str path: The path to put the file in the target node
        :param builtins.bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param builtins.str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param builtins.str permissions: The numeric representation of the file permissions
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        if dynamic is not None:
            pulumi.set(__self__, "dynamic", dynamic)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[builtins.bool]:
        """
        If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        """
        return pulumi.get(self, "dynamic")

    @property
    @pulumi.getter
    def hash(self) -> Optional[builtins.str]:
        """
        The base64 encoded value of the SHA256 checksum of the file's content
        """
        return pulumi.get(self, "hash")

    @property
    @pulumi.getter
    def permissions(self) -> Optional[builtins.str]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector(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 ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigMachineSelectorFileMachineLabelSelector.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 match_expressions: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpression']] = None,
                 match_labels: Optional[Mapping[str, builtins.str]] = None):
        """
        :param Sequence['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, builtins.str] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpression']]:
        """
        Label selector match expressions
        """
        return pulumi.get(self, "match_expressions")

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpression(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 values: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.str key: Label selector requirement key
        :param builtins.str operator: Label selector operator
        :param Sequence[builtins.str] values: Label selector requirement values
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[builtins.str]]:
        """
        Label selector requirement values
        """
        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: Registry config
        :param Sequence['ClusterV2RkeConfigRegistriesMirrorArgs'] mirrors: Registry mirrors
        """
        if configs is not None:
            pulumi.set(__self__, "configs", configs)
        if mirrors is not None:
            pulumi.set(__self__, "mirrors", mirrors)

    @property
    @pulumi.getter
    def configs(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigRegistriesConfig']]:
        """
        Registry config
        """
        return pulumi.get(self, "configs")

    @property
    @pulumi.getter
    def mirrors(self) -> Optional[Sequence['outputs.ClusterV2RkeConfigRegistriesMirror']]:
        """
        Registry mirrors
        """
        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: builtins.str,
                 auth_config_secret_name: Optional[builtins.str] = None,
                 ca_bundle: Optional[builtins.str] = None,
                 insecure: Optional[builtins.bool] = None,
                 tls_secret_name: Optional[builtins.str] = None):
        """
        :param builtins.str hostname: Registry hostname
        :param builtins.str auth_config_secret_name: Registry auth config secret name
        :param builtins.str ca_bundle: Registry CA bundle
        :param builtins.bool insecure: Registry insecure connectivity
        :param builtins.str tls_secret_name: Registry TLS secret name. TLS is a pair of Cert/Key
        """
        pulumi.set(__self__, "hostname", hostname)
        if auth_config_secret_name is not None:
            pulumi.set(__self__, "auth_config_secret_name", auth_config_secret_name)
        if ca_bundle is not None:
            pulumi.set(__self__, "ca_bundle", ca_bundle)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if tls_secret_name is not None:
            pulumi.set(__self__, "tls_secret_name", tls_secret_name)

    @property
    @pulumi.getter
    def hostname(self) -> builtins.str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter(name="authConfigSecretName")
    def auth_config_secret_name(self) -> Optional[builtins.str]:
        """
        Registry auth config secret name
        """
        return pulumi.get(self, "auth_config_secret_name")

    @property
    @pulumi.getter(name="caBundle")
    def ca_bundle(self) -> Optional[builtins.str]:
        """
        Registry CA bundle
        """
        return pulumi.get(self, "ca_bundle")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[builtins.bool]:
        """
        Registry insecure connectivity
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="tlsSecretName")
    def tls_secret_name(self) -> Optional[builtins.str]:
        """
        Registry TLS secret name. TLS is a pair of Cert/Key
        """
        return pulumi.get(self, "tls_secret_name")


@pulumi.output_type
class ClusterV2RkeConfigRegistriesMirror(dict):
    def __init__(__self__, *,
                 hostname: builtins.str,
                 endpoints: Optional[Sequence[builtins.str]] = None,
                 rewrites: Optional[Mapping[str, builtins.str]] = None):
        """
        :param builtins.str hostname: Registry hostname
        :param Sequence[builtins.str] endpoints: Registry mirror endpoints
        :param Mapping[str, builtins.str] rewrites: Registry mirror rewrites
        """
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

    @property
    @pulumi.getter
    def hostname(self) -> builtins.str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[Sequence[builtins.str]]:
        """
        Registry mirror endpoints
        """
        return pulumi.get(self, "endpoints")

    @property
    @pulumi.getter
    def rewrites(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Registry mirror rewrites
        """
        return pulumi.get(self, "rewrites")


@pulumi.output_type
class ClusterV2RkeConfigRotateCertificates(dict):
    def __init__(__self__, *,
                 generation: builtins.int,
                 services: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.int generation: Desired certificate rotation generation.
        :param Sequence[builtins.str] services: Service certificates to rotate with this generation.
        """
        pulumi.set(__self__, "generation", generation)
        if services is not None:
            pulumi.set(__self__, "services", services)

    @property
    @pulumi.getter
    def generation(self) -> builtins.int:
        """
        Desired certificate rotation generation.
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def services(self) -> Optional[Sequence[builtins.str]]:
        """
        Service certificates to rotate with this generation.
        """
        return pulumi.get(self, "services")


@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[builtins.str] = None,
                 control_plane_drain_options: Optional['outputs.ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions'] = None,
                 worker_concurrency: Optional[builtins.str] = None,
                 worker_drain_options: Optional['outputs.ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions'] = None):
        """
        :param builtins.str control_plane_concurrency: How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        :param 'ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs' control_plane_drain_options: Controlplane nodes drain options
        :param builtins.str worker_concurrency: How many worker nodes should be upgrade at time
        :param 'ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs' worker_drain_options: Worker nodes drain options
        """
        if control_plane_concurrency is not None:
            pulumi.set(__self__, "control_plane_concurrency", control_plane_concurrency)
        if control_plane_drain_options is not None:
            pulumi.set(__self__, "control_plane_drain_options", control_plane_drain_options)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)
        if worker_drain_options is not None:
            pulumi.set(__self__, "worker_drain_options", worker_drain_options)

    @property
    @pulumi.getter(name="controlPlaneConcurrency")
    def control_plane_concurrency(self) -> Optional[builtins.str]:
        """
        How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        """
        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
        """
        return pulumi.get(self, "control_plane_drain_options")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[builtins.str]:
        """
        How many worker nodes should be upgrade at time
        """
        return pulumi.get(self, "worker_concurrency")

    @property
    @pulumi.getter(name="workerDrainOptions")
    def worker_drain_options(self) -> Optional['outputs.ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions']:
        """
        Worker nodes drain options
        """
        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[builtins.bool] = None,
                 disable_eviction: Optional[builtins.bool] = None,
                 enabled: Optional[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 grace_period: Optional[builtins.int] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 ignore_errors: Optional[builtins.bool] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[builtins.int] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.bool delete_empty_dir_data: Drain options delete empty dir data
        :param builtins.bool disable_eviction: Drain options disable eviction
        :param builtins.bool enabled: Drain options enabled?
        :param builtins.bool force: Drain options force
        :param builtins.int grace_period: Drain options grace period
        :param builtins.bool ignore_daemon_sets: Drain options ignore daemon sets
        :param builtins.bool ignore_errors: Drain options ignore errors
        :param builtins.int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param builtins.int timeout: Drain options timeout
        """
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)
        if skip_wait_for_delete_timeout_seconds is not None:
            pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[builtins.bool]:
        """
        Drain options delete empty dir data
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[builtins.bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[builtins.int]:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[builtins.bool]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> Optional[builtins.int]:
        """
        Drain options skip wait for delete timeout seconds
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        Drain options timeout
        """
        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[builtins.bool] = None,
                 disable_eviction: Optional[builtins.bool] = None,
                 enabled: Optional[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 grace_period: Optional[builtins.int] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 ignore_errors: Optional[builtins.bool] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[builtins.int] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.bool delete_empty_dir_data: Drain options delete empty dir data
        :param builtins.bool disable_eviction: Drain options disable eviction
        :param builtins.bool enabled: Drain options enabled?
        :param builtins.bool force: Drain options force
        :param builtins.int grace_period: Drain options grace period
        :param builtins.bool ignore_daemon_sets: Drain options ignore daemon sets
        :param builtins.bool ignore_errors: Drain options ignore errors
        :param builtins.int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param builtins.int timeout: Drain options timeout
        """
        if delete_empty_dir_data is not None:
            pulumi.set(__self__, "delete_empty_dir_data", delete_empty_dir_data)
        if disable_eviction is not None:
            pulumi.set(__self__, "disable_eviction", disable_eviction)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if ignore_errors is not None:
            pulumi.set(__self__, "ignore_errors", ignore_errors)
        if skip_wait_for_delete_timeout_seconds is not None:
            pulumi.set(__self__, "skip_wait_for_delete_timeout_seconds", skip_wait_for_delete_timeout_seconds)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[builtins.bool]:
        """
        Drain options delete empty dir data
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[builtins.bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[builtins.int]:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[builtins.bool]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> Optional[builtins.int]:
        """
        Drain options skip wait for delete timeout seconds
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        Drain options timeout
        """
        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[builtins.bool] = None,
                 interval_hours: Optional[builtins.int] = None,
                 retention: Optional[builtins.int] = None,
                 s3_backup_config: Optional['outputs.EtcdBackupBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.bool enabled: Enable etcd backup (bool)
        :param builtins.int interval_hours: Interval hours for etcd backup. Default `12` (int)
        :param builtins.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[builtins.bool]:
        """
        Enable etcd backup (bool)
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[builtins.int]:
        """
        Interval hours for etcd backup. Default `12` (int)
        """
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "safe_timestamp")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.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: builtins.str,
                 endpoint: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 custom_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.str] = None):
        """
        :param builtins.str bucket_name: Bucket name for S3 service (string)
        :param builtins.str endpoint: Endpoint for S3 service (string)
        :param builtins.str access_key: Access key for S3 service (string)
        :param builtins.str custom_ca: Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
        :param builtins.str folder: Folder for S3 service. Available from Rancher v2.2.7 (string)
        :param builtins.str region: Region for S3 service (string)
        :param builtins.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) -> builtins.str:
        """
        Bucket name for S3 service (string)
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> builtins.str:
        """
        Endpoint for S3 service (string)
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[builtins.str]:
        """
        Access key for S3 service (string)
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[builtins.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[builtins.str]:
        """
        Folder for S3 service. Available from Rancher v2.2.7 (string)
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        Region for S3 service (string)
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.str]:
        """
        Secret key for S3 service (string)
        """
        return pulumi.get(self, "secret_key")


@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[builtins.str]] = None,
                 non_resource_urls: Optional[Sequence[builtins.str]] = None,
                 resource_names: Optional[Sequence[builtins.str]] = None,
                 resources: Optional[Sequence[builtins.str]] = None,
                 verbs: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] api_groups: Policy rule api groups
        :param Sequence[builtins.str] non_resource_urls: Policy rule non resource urls
        :param Sequence[builtins.str] resource_names: Policy rule resource names
        :param Sequence[builtins.str] resources: Policy rule resources
        :param Sequence[builtins.str] verbs: Policy rule verbs
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule verbs
        """
        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 == "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: builtins.str,
                 region: builtins.str,
                 security_groups: Sequence[builtins.str],
                 subnet_id: builtins.str,
                 vpc_id: builtins.str,
                 zone: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 block_duration_minutes: Optional[builtins.str] = None,
                 device_name: Optional[builtins.str] = None,
                 encrypt_ebs_volume: Optional[builtins.bool] = None,
                 endpoint: Optional[builtins.str] = None,
                 http_endpoint: Optional[builtins.str] = None,
                 http_tokens: Optional[builtins.str] = None,
                 iam_instance_profile: Optional[builtins.str] = None,
                 insecure_transport: Optional[builtins.bool] = None,
                 instance_type: Optional[builtins.str] = None,
                 kms_key: Optional[builtins.str] = None,
                 monitoring: Optional[builtins.bool] = None,
                 open_ports: Optional[Sequence[builtins.str]] = None,
                 private_address_only: Optional[builtins.bool] = None,
                 request_spot_instance: Optional[builtins.bool] = None,
                 retries: Optional[builtins.str] = None,
                 root_size: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.str] = None,
                 security_group_readonly: Optional[builtins.bool] = None,
                 session_token: Optional[builtins.str] = None,
                 spot_price: Optional[builtins.str] = None,
                 ssh_key_contents: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 use_ebs_optimized_instance: Optional[builtins.bool] = None,
                 use_private_address: Optional[builtins.bool] = None,
                 userdata: Optional[builtins.str] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.str ami: AWS machine image
        :param builtins.str region: AWS Region
        :param Sequence[builtins.str] security_groups: AWS VPC security group
        :param builtins.str subnet_id: AWS VPC subnet id
        :param builtins.str vpc_id: AWS VPC id
        :param builtins.str zone: AWS zone for instance (i.e. a,b,c,d,e)
        :param builtins.str access_key: AWS Access Key
        :param builtins.str block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        :param builtins.str device_name: AWS root device name
        :param builtins.bool encrypt_ebs_volume: Encrypt EBS volume
        :param builtins.str endpoint: Optional endpoint URL (hostname only or fully qualified URI)
        :param builtins.str http_endpoint: Enables or disables the HTTP metadata endpoint on your instances
        :param builtins.str http_tokens: The state of token usage for your instance metadata requests
        :param builtins.str iam_instance_profile: AWS IAM Instance Profile
        :param builtins.bool insecure_transport: Disable SSL when sending requests
        :param builtins.str instance_type: AWS instance type
        :param builtins.str kms_key: Custom KMS key ID using the AWS Managed CMK
        :param builtins.bool monitoring: Set this flag to enable CloudWatch monitoring
        :param Sequence[builtins.str] open_ports: Make the specified port number accessible from the Internet
        :param builtins.bool private_address_only: Only use a private IP address
        :param builtins.bool request_spot_instance: Set this flag to request spot instance
        :param builtins.str retries: Set retry count for recoverable failures (use -1 to disable)
        :param builtins.str root_size: AWS root disk size (in GB)
        :param builtins.str secret_key: AWS Secret Key
        :param builtins.bool security_group_readonly: Skip adding default rules to security groups
        :param builtins.str session_token: AWS Session Token
        :param builtins.str spot_price: AWS spot instance bid price (in dollar)
        :param builtins.str ssh_key_contents: SSH Key file contents for sshKeyContents
        :param builtins.str ssh_user: Set the name of the ssh user
        :param builtins.str tags: AWS Tags (e.g. key1,value1,key2,value2)
        :param builtins.bool use_ebs_optimized_instance: Create an EBS optimized instance
        :param builtins.bool use_private_address: Force the usage of private IP address
        :param builtins.str userdata: Path to file with cloud-init user data
        :param builtins.str volume_type: Amazon EBS volume type
        """
        pulumi.set(__self__, "ami", ami)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "security_groups", security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "zone", zone)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if encrypt_ebs_volume is not None:
            pulumi.set(__self__, "encrypt_ebs_volume", encrypt_ebs_volume)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if http_tokens is not None:
            pulumi.set(__self__, "http_tokens", http_tokens)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if insecure_transport is not None:
            pulumi.set(__self__, "insecure_transport", insecure_transport)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_address_only is not None:
            pulumi.set(__self__, "private_address_only", private_address_only)
        if request_spot_instance is not None:
            pulumi.set(__self__, "request_spot_instance", request_spot_instance)
        if retries is not None:
            pulumi.set(__self__, "retries", retries)
        if root_size is not None:
            pulumi.set(__self__, "root_size", root_size)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)
        if security_group_readonly is not None:
            pulumi.set(__self__, "security_group_readonly", security_group_readonly)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if ssh_key_contents is not None:
            pulumi.set(__self__, "ssh_key_contents", ssh_key_contents)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if use_ebs_optimized_instance is not None:
            pulumi.set(__self__, "use_ebs_optimized_instance", use_ebs_optimized_instance)
        if use_private_address is not None:
            pulumi.set(__self__, "use_private_address", use_private_address)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def ami(self) -> builtins.str:
        """
        AWS machine image
        """
        return pulumi.get(self, "ami")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        """
        AWS Region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Sequence[builtins.str]:
        """
        AWS VPC security group
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        AWS VPC subnet id
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        AWS VPC id
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter
    def zone(self) -> builtins.str:
        """
        AWS zone for instance (i.e. a,b,c,d,e)
        """
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[builtins.str]:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[builtins.str]:
        """
        AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        """
        return pulumi.get(self, "block_duration_minutes")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[builtins.str]:
        """
        AWS root device name
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="encryptEbsVolume")
    def encrypt_ebs_volume(self) -> Optional[builtins.bool]:
        """
        Encrypt EBS volume
        """
        return pulumi.get(self, "encrypt_ebs_volume")

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[builtins.str]:
        """
        Optional endpoint URL (hostname only or fully qualified URI)
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="httpEndpoint")
    def http_endpoint(self) -> Optional[builtins.str]:
        """
        Enables or disables the HTTP metadata endpoint on your instances
        """
        return pulumi.get(self, "http_endpoint")

    @property
    @pulumi.getter(name="httpTokens")
    def http_tokens(self) -> Optional[builtins.str]:
        """
        The state of token usage for your instance metadata requests
        """
        return pulumi.get(self, "http_tokens")

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional[builtins.str]:
        """
        AWS IAM Instance Profile
        """
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="insecureTransport")
    def insecure_transport(self) -> Optional[builtins.bool]:
        """
        Disable SSL when sending requests
        """
        return pulumi.get(self, "insecure_transport")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        AWS instance type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[builtins.str]:
        """
        Custom KMS key ID using the AWS Managed CMK
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[builtins.bool]:
        """
        Set this flag to enable CloudWatch monitoring
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[Sequence[builtins.str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[builtins.bool]:
        """
        Only use a private IP address
        """
        return pulumi.get(self, "private_address_only")

    @property
    @pulumi.getter(name="requestSpotInstance")
    def request_spot_instance(self) -> Optional[builtins.bool]:
        """
        Set this flag to request spot instance
        """
        return pulumi.get(self, "request_spot_instance")

    @property
    @pulumi.getter
    def retries(self) -> Optional[builtins.str]:
        """
        Set retry count for recoverable failures (use -1 to disable)
        """
        return pulumi.get(self, "retries")

    @property
    @pulumi.getter(name="rootSize")
    def root_size(self) -> Optional[builtins.str]:
        """
        AWS root disk size (in GB)
        """
        return pulumi.get(self, "root_size")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.str]:
        """
        AWS Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="securityGroupReadonly")
    def security_group_readonly(self) -> Optional[builtins.bool]:
        """
        Skip adding default rules to security groups
        """
        return pulumi.get(self, "security_group_readonly")

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[builtins.str]:
        """
        AWS Session Token
        """
        return pulumi.get(self, "session_token")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[builtins.str]:
        """
        AWS spot instance bid price (in dollar)
        """
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="sshKeyContents")
    def ssh_key_contents(self) -> Optional[builtins.str]:
        """
        SSH Key file contents for sshKeyContents
        """
        return pulumi.get(self, "ssh_key_contents")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        Set the name of the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        AWS Tags (e.g. key1,value1,key2,value2)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="useEbsOptimizedInstance")
    def use_ebs_optimized_instance(self) -> Optional[builtins.bool]:
        """
        Create an EBS optimized instance
        """
        return pulumi.get(self, "use_ebs_optimized_instance")

    @property
    @pulumi.getter(name="usePrivateAddress")
    def use_private_address(self) -> Optional[builtins.bool]:
        """
        Force the usage of private IP address
        """
        return pulumi.get(self, "use_private_address")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[builtins.str]:
        """
        Path to file with cloud-init user data
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[builtins.str]:
        """
        Amazon EBS volume type
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class MachineConfigV2AzureConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acceleratedNetworking":
            suggest = "accelerated_networking"
        elif key == "availabilitySet":
            suggest = "availability_set"
        elif key == "availabilityZone":
            suggest = "availability_zone"
        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 == "privateAddressOnly":
            suggest = "private_address_only"
        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"
        elif key == "usePublicIpStandardSku":
            suggest = "use_public_ip_standard_sku"

        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__, *,
                 accelerated_networking: Optional[builtins.bool] = None,
                 availability_set: Optional[builtins.str] = None,
                 availability_zone: Optional[builtins.str] = None,
                 client_id: Optional[builtins.str] = None,
                 client_secret: Optional[builtins.str] = None,
                 custom_data: Optional[builtins.str] = None,
                 disk_size: Optional[builtins.str] = None,
                 dns: Optional[builtins.str] = None,
                 docker_port: Optional[builtins.str] = None,
                 environment: Optional[builtins.str] = None,
                 fault_domain_count: Optional[builtins.str] = None,
                 image: Optional[builtins.str] = None,
                 location: Optional[builtins.str] = None,
                 managed_disks: Optional[builtins.bool] = None,
                 no_public_ip: Optional[builtins.bool] = None,
                 nsg: Optional[builtins.str] = None,
                 open_ports: Optional[Sequence[builtins.str]] = None,
                 private_address_only: Optional[builtins.bool] = None,
                 private_ip_address: Optional[builtins.str] = None,
                 resource_group: Optional[builtins.str] = None,
                 size: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 static_public_ip: Optional[builtins.bool] = None,
                 storage_type: Optional[builtins.str] = None,
                 subnet: Optional[builtins.str] = None,
                 subnet_prefix: Optional[builtins.str] = None,
                 subscription_id: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 tenant_id: Optional[builtins.str] = None,
                 update_domain_count: Optional[builtins.str] = None,
                 use_private_ip: Optional[builtins.bool] = None,
                 use_public_ip_standard_sku: Optional[builtins.bool] = None,
                 vnet: Optional[builtins.str] = None):
        """
        :param builtins.bool accelerated_networking: Use Accelerated Networking when creating a network interface for the Azure VM
        :param builtins.str availability_set: Azure Availability Set to place the virtual machine into
        :param builtins.str availability_zone: The Availability Zone that the Azure VM should be created in
        :param builtins.str client_id: Azure Service Principal Account ID (optional, browser auth is used if not specified)
        :param builtins.str client_secret: Azure Service Principal Account password (optional, browser auth is used if not specified)
        :param builtins.str custom_data: Path to file with custom-data
        :param builtins.str disk_size: Disk size if using managed disk
        :param builtins.str dns: A unique DNS label for the public IP adddress
        :param builtins.str docker_port: Port number for Docker engine
        :param builtins.str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param builtins.str fault_domain_count: Fault domain count to use for availability set
        :param builtins.str image: Azure virtual machine OS image
        :param builtins.str location: Azure region to create the virtual machine
        :param builtins.bool managed_disks: Configures VM and availability set for managed disks
        :param builtins.bool no_public_ip: Do not create a public IP address for the machine
        :param builtins.str nsg: Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine)
        :param Sequence[builtins.str] open_ports: Make the specified port number accessible from the Internet
        :param builtins.bool private_address_only: Only use a private IP address
        :param builtins.str private_ip_address: Specify a static private IP address for the machine
        :param builtins.str resource_group: Azure Resource Group name (will be created if missing)
        :param builtins.str size: Size for Azure Virtual Machine
        :param builtins.str ssh_user: Username for SSH login
        :param builtins.bool static_public_ip: Assign a static public IP address to the machine
        :param builtins.str storage_type: Type of Storage Account to host the OS Disk for the machine
        :param builtins.str subnet: Azure Subnet Name to be used within the Virtual Network
        :param builtins.str subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918
        :param builtins.str subscription_id: Azure Subscription ID
        :param builtins.str tags: Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        :param builtins.str tenant_id: Azure Tenant ID
        :param builtins.str update_domain_count: Update domain count to use for availability set
        :param builtins.bool use_private_ip: Use private IP address of the machine to connect
        :param builtins.bool use_public_ip_standard_sku: Use the standard SKU when creating a Public IP for the Azure VM instance
        :param builtins.str vnet: Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        if accelerated_networking is not None:
            pulumi.set(__self__, "accelerated_networking", accelerated_networking)
        if availability_set is not None:
            pulumi.set(__self__, "availability_set", availability_set)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if custom_data is not None:
            pulumi.set(__self__, "custom_data", custom_data)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if fault_domain_count is not None:
            pulumi.set(__self__, "fault_domain_count", fault_domain_count)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if managed_disks is not None:
            pulumi.set(__self__, "managed_disks", managed_disks)
        if no_public_ip is not None:
            pulumi.set(__self__, "no_public_ip", no_public_ip)
        if nsg is not None:
            pulumi.set(__self__, "nsg", nsg)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_address_only is not None:
            pulumi.set(__self__, "private_address_only", private_address_only)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if static_public_ip is not None:
            pulumi.set(__self__, "static_public_ip", static_public_ip)
        if storage_type is not None:
            pulumi.set(__self__, "storage_type", storage_type)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if subnet_prefix is not None:
            pulumi.set(__self__, "subnet_prefix", subnet_prefix)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if update_domain_count is not None:
            pulumi.set(__self__, "update_domain_count", update_domain_count)
        if use_private_ip is not None:
            pulumi.set(__self__, "use_private_ip", use_private_ip)
        if use_public_ip_standard_sku is not None:
            pulumi.set(__self__, "use_public_ip_standard_sku", use_public_ip_standard_sku)
        if vnet is not None:
            pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="acceleratedNetworking")
    def accelerated_networking(self) -> Optional[builtins.bool]:
        """
        Use Accelerated Networking when creating a network interface for the Azure VM
        """
        return pulumi.get(self, "accelerated_networking")

    @property
    @pulumi.getter(name="availabilitySet")
    def availability_set(self) -> Optional[builtins.str]:
        """
        Azure Availability Set to place the virtual machine into
        """
        return pulumi.get(self, "availability_set")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[builtins.str]:
        """
        The Availability Zone that the Azure VM should be created in
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[builtins.str]:
        """
        Azure Service Principal Account ID (optional, browser auth is used if not specified)
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[builtins.str]:
        """
        Azure Service Principal Account password (optional, browser auth is used if not specified)
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="customData")
    def custom_data(self) -> Optional[builtins.str]:
        """
        Path to file with custom-data
        """
        return pulumi.get(self, "custom_data")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[builtins.str]:
        """
        Disk size if using managed disk
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def dns(self) -> Optional[builtins.str]:
        """
        A unique DNS label for the public IP adddress
        """
        return pulumi.get(self, "dns")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[builtins.str]:
        """
        Port number for Docker engine
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def environment(self) -> Optional[builtins.str]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="faultDomainCount")
    def fault_domain_count(self) -> Optional[builtins.str]:
        """
        Fault domain count to use for availability set
        """
        return pulumi.get(self, "fault_domain_count")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Azure virtual machine OS image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def location(self) -> Optional[builtins.str]:
        """
        Azure region to create the virtual machine
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="managedDisks")
    def managed_disks(self) -> Optional[builtins.bool]:
        """
        Configures VM and availability set for managed disks
        """
        return pulumi.get(self, "managed_disks")

    @property
    @pulumi.getter(name="noPublicIp")
    def no_public_ip(self) -> Optional[builtins.bool]:
        """
        Do not create a public IP address for the machine
        """
        return pulumi.get(self, "no_public_ip")

    @property
    @pulumi.getter
    def nsg(self) -> Optional[builtins.str]:
        """
        Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine)
        """
        return pulumi.get(self, "nsg")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[Sequence[builtins.str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[builtins.bool]:
        """
        Only use a private IP address
        """
        return pulumi.get(self, "private_address_only")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[builtins.str]:
        """
        Specify a static private IP address for the machine
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[builtins.str]:
        """
        Azure Resource Group name (will be created if missing)
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.str]:
        """
        Size for Azure Virtual Machine
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        Username for SSH login
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="staticPublicIp")
    def static_public_ip(self) -> Optional[builtins.bool]:
        """
        Assign a static public IP address to the machine
        """
        return pulumi.get(self, "static_public_ip")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[builtins.str]:
        """
        Type of Storage Account to host the OS Disk for the machine
        """
        return pulumi.get(self, "storage_type")

    @property
    @pulumi.getter
    def subnet(self) -> Optional[builtins.str]:
        """
        Azure Subnet Name to be used within the Virtual Network
        """
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter(name="subnetPrefix")
    def subnet_prefix(self) -> Optional[builtins.str]:
        """
        Private CIDR block to be used for the new subnet, should comply RFC 1918
        """
        return pulumi.get(self, "subnet_prefix")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[builtins.str]:
        """
        Azure Subscription ID
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[builtins.str]:
        """
        Azure Tenant ID
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="updateDomainCount")
    def update_domain_count(self) -> Optional[builtins.str]:
        """
        Update domain count to use for availability set
        """
        return pulumi.get(self, "update_domain_count")

    @property
    @pulumi.getter(name="usePrivateIp")
    def use_private_ip(self) -> Optional[builtins.bool]:
        """
        Use private IP address of the machine to connect
        """
        return pulumi.get(self, "use_private_ip")

    @property
    @pulumi.getter(name="usePublicIpStandardSku")
    def use_public_ip_standard_sku(self) -> Optional[builtins.bool]:
        """
        Use the standard SKU when creating a Public IP for the Azure VM instance
        """
        return pulumi.get(self, "use_public_ip_standard_sku")

    @property
    @pulumi.getter
    def vnet(self) -> Optional[builtins.str]:
        """
        Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        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[builtins.str] = None,
                 backups: Optional[builtins.bool] = None,
                 image: Optional[builtins.str] = None,
                 ipv6: Optional[builtins.bool] = None,
                 monitoring: Optional[builtins.bool] = None,
                 private_networking: Optional[builtins.bool] = None,
                 region: Optional[builtins.str] = None,
                 size: Optional[builtins.str] = None,
                 ssh_key_contents: Optional[builtins.str] = None,
                 ssh_key_fingerprint: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 userdata: Optional[builtins.str] = None):
        """
        :param builtins.str access_token: Digital Ocean access token
        :param builtins.bool backups: Enable backups for droplet
        :param builtins.str image: Digital Ocean Image
        :param builtins.bool ipv6: Enable ipv6 for droplet
        :param builtins.bool monitoring: Enable monitoring for droplet
        :param builtins.bool private_networking: Enable private networking for droplet
        :param builtins.str region: Digital Ocean region
        :param builtins.str size: Digital Ocean size
        :param builtins.str ssh_key_contents: SSH private key contents
        :param builtins.str ssh_key_fingerprint: SSH key fingerprint
        :param builtins.str ssh_port: SSH port
        :param builtins.str ssh_user: SSH username
        :param builtins.str tags: Comma-separated list of tags to apply to the Droplet
        :param builtins.str userdata: Path to file with cloud-init user-data
        """
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if backups is not None:
            pulumi.set(__self__, "backups", backups)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if private_networking is not None:
            pulumi.set(__self__, "private_networking", private_networking)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_key_contents is not None:
            pulumi.set(__self__, "ssh_key_contents", ssh_key_contents)
        if ssh_key_fingerprint is not None:
            pulumi.set(__self__, "ssh_key_fingerprint", ssh_key_fingerprint)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[builtins.str]:
        """
        Digital Ocean access token
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter
    def backups(self) -> Optional[builtins.bool]:
        """
        Enable backups for droplet
        """
        return pulumi.get(self, "backups")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Digital Ocean Image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[builtins.bool]:
        """
        Enable ipv6 for droplet
        """
        return pulumi.get(self, "ipv6")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[builtins.bool]:
        """
        Enable monitoring for droplet
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="privateNetworking")
    def private_networking(self) -> Optional[builtins.bool]:
        """
        Enable private networking for droplet
        """
        return pulumi.get(self, "private_networking")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        Digital Ocean region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.str]:
        """
        Digital Ocean size
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshKeyContents")
    def ssh_key_contents(self) -> Optional[builtins.str]:
        """
        SSH private key contents
        """
        return pulumi.get(self, "ssh_key_contents")

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[builtins.str]:
        """
        SSH key fingerprint
        """
        return pulumi.get(self, "ssh_key_fingerprint")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[builtins.str]:
        """
        SSH port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        Comma-separated list of tags to apply to the Droplet
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[builtins.str]:
        """
        Path to file with cloud-init user-data
        """
        return pulumi.get(self, "userdata")


@pulumi.output_type
class MachineConfigV2HarvesterConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sshUser":
            suggest = "ssh_user"
        elif key == "vmNamespace":
            suggest = "vm_namespace"
        elif key == "cpuCount":
            suggest = "cpu_count"
        elif key == "diskBus":
            suggest = "disk_bus"
        elif key == "diskInfo":
            suggest = "disk_info"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "memorySize":
            suggest = "memory_size"
        elif key == "networkData":
            suggest = "network_data"
        elif key == "networkInfo":
            suggest = "network_info"
        elif key == "networkModel":
            suggest = "network_model"
        elif key == "networkName":
            suggest = "network_name"
        elif key == "sshPassword":
            suggest = "ssh_password"
        elif key == "userData":
            suggest = "user_data"
        elif key == "vmAffinity":
            suggest = "vm_affinity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2HarvesterConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2HarvesterConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2HarvesterConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ssh_user: builtins.str,
                 vm_namespace: builtins.str,
                 cpu_count: Optional[builtins.str] = None,
                 disk_bus: Optional[builtins.str] = None,
                 disk_info: Optional[builtins.str] = None,
                 disk_size: Optional[builtins.str] = None,
                 image_name: Optional[builtins.str] = None,
                 memory_size: Optional[builtins.str] = None,
                 network_data: Optional[builtins.str] = None,
                 network_info: Optional[builtins.str] = None,
                 network_model: Optional[builtins.str] = None,
                 network_name: Optional[builtins.str] = None,
                 ssh_password: Optional[builtins.str] = None,
                 user_data: Optional[builtins.str] = None,
                 vm_affinity: Optional[builtins.str] = None):
        """
        :param builtins.str ssh_user: SSH username
        :param builtins.str vm_namespace: Virtual machine namespace
        :param builtins.str cpu_count: CPU count
        :param builtins.str disk_bus: Disk bus
        :param builtins.str disk_info: A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        :param builtins.str disk_size: Disk size (in GiB)
        :param builtins.str image_name: Image name
        :param builtins.str memory_size: Memory size (in GiB)
        :param builtins.str network_data: NetworkData content of cloud-init, base64 is supported
        :param builtins.str network_info: A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        :param builtins.str network_model: Network model
        :param builtins.str network_name: Network name
        :param builtins.str ssh_password: SSH password
        :param builtins.str user_data: UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        :param builtins.str vm_affinity: VM affinity, base64 is supported
        """
        pulumi.set(__self__, "ssh_user", ssh_user)
        pulumi.set(__self__, "vm_namespace", vm_namespace)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if disk_bus is not None:
            pulumi.set(__self__, "disk_bus", disk_bus)
        if disk_info is not None:
            pulumi.set(__self__, "disk_info", disk_info)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if network_data is not None:
            pulumi.set(__self__, "network_data", network_data)
        if network_info is not None:
            pulumi.set(__self__, "network_info", network_info)
        if network_model is not None:
            pulumi.set(__self__, "network_model", network_model)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if vm_affinity is not None:
            pulumi.set(__self__, "vm_affinity", vm_affinity)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> builtins.str:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="vmNamespace")
    def vm_namespace(self) -> builtins.str:
        """
        Virtual machine namespace
        """
        return pulumi.get(self, "vm_namespace")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[builtins.str]:
        """
        CPU count
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="diskBus")
    @_utilities.deprecated("""Use disk_info instead""")
    def disk_bus(self) -> Optional[builtins.str]:
        """
        Disk bus
        """
        return pulumi.get(self, "disk_bus")

    @property
    @pulumi.getter(name="diskInfo")
    def disk_info(self) -> Optional[builtins.str]:
        """
        A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        """
        return pulumi.get(self, "disk_info")

    @property
    @pulumi.getter(name="diskSize")
    @_utilities.deprecated("""Use disk_info instead""")
    def disk_size(self) -> Optional[builtins.str]:
        """
        Disk size (in GiB)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter(name="imageName")
    @_utilities.deprecated("""Use disk_info instead""")
    def image_name(self) -> Optional[builtins.str]:
        """
        Image name
        """
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[builtins.str]:
        """
        Memory size (in GiB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter(name="networkData")
    def network_data(self) -> Optional[builtins.str]:
        """
        NetworkData content of cloud-init, base64 is supported
        """
        return pulumi.get(self, "network_data")

    @property
    @pulumi.getter(name="networkInfo")
    def network_info(self) -> Optional[builtins.str]:
        """
        A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        """
        return pulumi.get(self, "network_info")

    @property
    @pulumi.getter(name="networkModel")
    @_utilities.deprecated("""Use network_info instead""")
    def network_model(self) -> Optional[builtins.str]:
        """
        Network model
        """
        return pulumi.get(self, "network_model")

    @property
    @pulumi.getter(name="networkName")
    @_utilities.deprecated("""Use network_info instead""")
    def network_name(self) -> Optional[builtins.str]:
        """
        Network name
        """
        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[builtins.str]:
        """
        SSH password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[builtins.str]:
        """
        UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        """
        return pulumi.get(self, "user_data")

    @property
    @pulumi.getter(name="vmAffinity")
    def vm_affinity(self) -> Optional[builtins.str]:
        """
        VM affinity, base64 is supported
        """
        return pulumi.get(self, "vm_affinity")


@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[builtins.str] = None,
                 create_private_ip: Optional[builtins.bool] = None,
                 docker_port: Optional[builtins.str] = None,
                 image: Optional[builtins.str] = None,
                 instance_type: Optional[builtins.str] = None,
                 label: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 root_pass: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 stackscript: Optional[builtins.str] = None,
                 stackscript_data: Optional[builtins.str] = None,
                 swap_size: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 token: Optional[builtins.str] = None,
                 ua_prefix: Optional[builtins.str] = None):
        """
        :param builtins.str authorized_users: Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node
        :param builtins.bool create_private_ip: Create private IP for the instance
        :param builtins.str docker_port: Docker Port
        :param builtins.str image: Specifies the Linode Instance image which determines the OS distribution and base files
        :param builtins.str instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        :param builtins.str label: Linode Instance Label
        :param builtins.str region: Specifies the region (location) of the Linode instance
        :param builtins.str root_pass: Root Password
        :param builtins.str ssh_port: Linode Instance SSH Port
        :param builtins.str ssh_user: Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        :param builtins.str stackscript: Specifies the Linode StackScript to use to create the instance
        :param builtins.str stackscript_data: A JSON string specifying data for the selected StackScript
        :param builtins.str swap_size: Linode Instance Swap Size (MB)
        :param builtins.str tags: A comma separated list of tags to apply to the the Linode resource
        :param builtins.str token: Linode API Token
        :param builtins.str ua_prefix: Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        if authorized_users is not None:
            pulumi.set(__self__, "authorized_users", authorized_users)
        if create_private_ip is not None:
            pulumi.set(__self__, "create_private_ip", create_private_ip)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if root_pass is not None:
            pulumi.set(__self__, "root_pass", root_pass)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if stackscript is not None:
            pulumi.set(__self__, "stackscript", stackscript)
        if stackscript_data is not None:
            pulumi.set(__self__, "stackscript_data", stackscript_data)
        if swap_size is not None:
            pulumi.set(__self__, "swap_size", swap_size)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if ua_prefix is not None:
            pulumi.set(__self__, "ua_prefix", ua_prefix)

    @property
    @pulumi.getter(name="authorizedUsers")
    def authorized_users(self) -> Optional[builtins.str]:
        """
        Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node
        """
        return pulumi.get(self, "authorized_users")

    @property
    @pulumi.getter(name="createPrivateIp")
    def create_private_ip(self) -> Optional[builtins.bool]:
        """
        Create private IP for the instance
        """
        return pulumi.get(self, "create_private_ip")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[builtins.str]:
        """
        Docker Port
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def label(self) -> Optional[builtins.str]:
        """
        Linode Instance Label
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        Specifies the region (location) of the Linode instance
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="rootPass")
    def root_pass(self) -> Optional[builtins.str]:
        """
        Root Password
        """
        return pulumi.get(self, "root_pass")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[builtins.str]:
        """
        Linode Instance SSH Port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def stackscript(self) -> Optional[builtins.str]:
        """
        Specifies the Linode StackScript to use to create the instance
        """
        return pulumi.get(self, "stackscript")

    @property
    @pulumi.getter(name="stackscriptData")
    def stackscript_data(self) -> Optional[builtins.str]:
        """
        A JSON string specifying data for the selected StackScript
        """
        return pulumi.get(self, "stackscript_data")

    @property
    @pulumi.getter(name="swapSize")
    def swap_size(self) -> Optional[builtins.str]:
        """
        Linode Instance Swap Size (MB)
        """
        return pulumi.get(self, "swap_size")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        A comma separated list of tags to apply to the the Linode resource
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def token(self) -> Optional[builtins.str]:
        """
        Linode API Token
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="uaPrefix")
    def ua_prefix(self) -> Optional[builtins.str]:
        """
        Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        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: builtins.str,
                 availability_zone: builtins.str,
                 region: builtins.str,
                 active_timeout: Optional[builtins.str] = None,
                 application_credential_id: Optional[builtins.str] = None,
                 application_credential_name: Optional[builtins.str] = None,
                 application_credential_secret: Optional[builtins.str] = None,
                 boot_from_volume: Optional[builtins.bool] = None,
                 cacert: Optional[builtins.str] = None,
                 config_drive: Optional[builtins.bool] = None,
                 domain_id: Optional[builtins.str] = None,
                 domain_name: Optional[builtins.str] = None,
                 endpoint_type: Optional[builtins.str] = None,
                 flavor_id: Optional[builtins.str] = None,
                 flavor_name: Optional[builtins.str] = None,
                 floating_ip_pool: Optional[builtins.str] = None,
                 image_id: Optional[builtins.str] = None,
                 image_name: Optional[builtins.str] = None,
                 insecure: Optional[builtins.bool] = None,
                 ip_version: Optional[builtins.str] = None,
                 keypair_name: Optional[builtins.str] = None,
                 net_id: Optional[builtins.str] = None,
                 net_name: Optional[builtins.str] = None,
                 nova_network: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 private_key_file: Optional[builtins.str] = None,
                 sec_groups: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 tenant_domain_id: Optional[builtins.str] = None,
                 tenant_domain_name: Optional[builtins.str] = None,
                 tenant_id: Optional[builtins.str] = None,
                 tenant_name: Optional[builtins.str] = None,
                 user_data_file: Optional[builtins.str] = None,
                 user_domain_id: Optional[builtins.str] = None,
                 user_domain_name: Optional[builtins.str] = None,
                 username: Optional[builtins.str] = None,
                 volume_device_path: Optional[builtins.str] = None,
                 volume_id: Optional[builtins.str] = None,
                 volume_name: Optional[builtins.str] = None,
                 volume_size: Optional[builtins.str] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.str auth_url: OpenStack authentication URL (string)
        :param builtins.str availability_zone: OpenStack availability zone (string)
        :param builtins.str region: OpenStack region name (string)
        :param builtins.str active_timeout: OpenStack active timeout Default `200` (string)
        :param builtins.str application_credential_id: OpenStack application credential id. Conflicts with `application_credential_name` (string)
        :param builtins.str application_credential_name: OpenStack application credential name. Conflicts with `application_credential_id` (string)
        :param builtins.str application_credential_secret: OpenStack application credential secret (string)
        :param builtins.bool boot_from_volume: Enable booting from volume. Default is `false` (bool)
        :param builtins.str cacert: CA certificate bundle to verify against (string)
        :param builtins.bool config_drive: Enables the OpenStack config drive for the instance. Default `false` (bool)
        :param builtins.str domain_id: OpenStack domain ID. Identity v3 only. Conflicts with `domain_name` (string)
        :param builtins.str domain_name: OpenStack domain name. Identity v3 only. Conflicts with `domain_id` (string)
        :param builtins.str endpoint_type: OpenStack endpoint type. adminURL, internalURL or publicURL (string)
        :param builtins.str flavor_id: OpenStack flavor id to use for the instance. Conflicts with `flavor_name` (string)
        :param builtins.str flavor_name: OpenStack flavor name to use for the instance. Conflicts with `flavor_id` (string)
        :param builtins.str floating_ip_pool: OpenStack floating IP pool to get an IP from to assign to the instance (string)
        :param builtins.str image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param builtins.str image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param builtins.bool insecure: Disable TLS credential checking. Default `false` (bool)
        :param builtins.str ip_version: OpenStack version of IP address assigned for the machine Default `4` (string)
        :param builtins.str keypair_name: OpenStack keypair to use to SSH to the instance (string)
        :param builtins.str net_id: OpenStack network id the machine will be connected on. Conflicts with `net_name` (string)
        :param builtins.str net_name: OpenStack network name the machine will be connected on. Conflicts with `net_id` (string)
        :param builtins.bool nova_network: Use the nova networking services instead of neutron (string)
        :param builtins.str password: OpenStack password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param builtins.str private_key_file: Private key content to use for SSH (string)
        :param builtins.str sec_groups: OpenStack comma separated security groups for the machine (string)
        :param builtins.str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22` (string)
        :param builtins.str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. (string)
        :param builtins.str tenant_domain_id: OpenStack tenant domain id. Conflicts with `tenant_domain_name` (string)
        :param builtins.str tenant_domain_name: OpenStack tenant domain name. Conflicts with `tenant_domain_id` (string)
        :param builtins.str tenant_id: OpenStack tenant id. Conflicts with `tenant_name` (string)
        :param builtins.str tenant_name: OpenStack tenant name. Conflicts with `tenant_id` (string)
        :param builtins.str user_data_file: File containing an openstack userdata script (string)
        :param builtins.str user_domain_id: OpenStack user domain id. Conflicts with `user_domain_name` (string)
        :param builtins.str user_domain_name: OpenStack user domain name. Conflicts with `user_domain_id` (string)
        :param builtins.str username: OpenStack username (string)
        :param builtins.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.
               > **Note for OpenStack users:**: `keypair_name` is required to be in the schema even if there are no references in rancher itself
        :param builtins.str volume_id: OpenStack volume id of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param builtins.str volume_name: OpenStack volume name of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param builtins.str volume_size: OpenStack volume size (GiB). Required when `boot_from_volume` is `true` (string)
        :param builtins.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) -> builtins.str:
        """
        OpenStack authentication URL (string)
        """
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        """
        OpenStack availability zone (string)
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        """
        OpenStack region name (string)
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[builtins.str]:
        """
        OpenStack active timeout Default `200` (string)
        """
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[builtins.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[builtins.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[builtins.str]:
        """
        OpenStack application credential secret (string)
        """
        return pulumi.get(self, "application_credential_secret")

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[builtins.bool]:
        """
        Enable booting from volume. Default is `false` (bool)
        """
        return pulumi.get(self, "boot_from_volume")

    @property
    @pulumi.getter
    def cacert(self) -> Optional[builtins.str]:
        """
        CA certificate bundle to verify against (string)
        """
        return pulumi.get(self, "cacert")

    @property
    @pulumi.getter(name="configDrive")
    def config_drive(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.bool]:
        """
        Disable TLS credential checking. Default `false` (bool)
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.bool]:
        """
        Use the nova networking services instead of neutron (string)
        """
        return pulumi.get(self, "nova_network")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.str]:
        """
        OpenStack username (string)
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="volumeDevicePath")
    def volume_device_path(self) -> Optional[builtins.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.
        > **Note for OpenStack users:**: `keypair_name` is required to be in the schema even if there are no references in rancher itself
        """
        return pulumi.get(self, "volume_device_path")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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 == "gracefulShutdownTimeout":
            suggest = "graceful_shutdown_timeout"
        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[builtins.str] = None,
                 cfgparams: Optional[Sequence[builtins.str]] = None,
                 clone_from: Optional[builtins.str] = None,
                 cloud_config: Optional[builtins.str] = None,
                 cloudinit: Optional[builtins.str] = None,
                 content_library: Optional[builtins.str] = None,
                 cpu_count: Optional[builtins.str] = None,
                 creation_type: Optional[builtins.str] = None,
                 custom_attributes: Optional[Sequence[builtins.str]] = None,
                 datacenter: Optional[builtins.str] = None,
                 datastore: Optional[builtins.str] = None,
                 datastore_cluster: Optional[builtins.str] = None,
                 disk_size: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 graceful_shutdown_timeout: Optional[builtins.str] = None,
                 hostsystem: Optional[builtins.str] = None,
                 memory_size: Optional[builtins.str] = None,
                 networks: Optional[Sequence[builtins.str]] = None,
                 password: Optional[builtins.str] = None,
                 pool: Optional[builtins.str] = None,
                 ssh_password: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 ssh_user_group: Optional[builtins.str] = None,
                 tags: Optional[Sequence[builtins.str]] = None,
                 username: Optional[builtins.str] = None,
                 vapp_ip_allocation_policy: Optional[builtins.str] = None,
                 vapp_ip_protocol: Optional[builtins.str] = None,
                 vapp_properties: Optional[Sequence[builtins.str]] = None,
                 vapp_transport: Optional[builtins.str] = None,
                 vcenter: Optional[builtins.str] = None,
                 vcenter_port: Optional[builtins.str] = None):
        """
        :param builtins.str boot2docker_url: vSphere URL for boot2docker image
        :param Sequence[builtins.str] cfgparams: vSphere vm configuration parameters (used for guestinfo)
        :param builtins.str clone_from: If you choose creation type clone a name of what you want to clone is required
        :param builtins.str cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data
        :param builtins.str cloudinit: vSphere cloud-init filepath or url to add to guestinfo
        :param builtins.str content_library: If you choose to clone from a content library template specify the name of the library
        :param builtins.str cpu_count: vSphere CPU number for docker VM
        :param builtins.str creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        :param Sequence[builtins.str] custom_attributes: vSphere custom attributes, format key/value e.g. '200=my custom value'
        :param builtins.str datacenter: vSphere datacenter for virtual machine
        :param builtins.str datastore: vSphere datastore for virtual machine
        :param builtins.str datastore_cluster: vSphere datastore cluster for virtual machine
        :param builtins.str disk_size: vSphere size of disk for docker VM (in MB)
        :param builtins.str folder: vSphere folder for the docker VM. This folder must already exist in the datacenter
        :param builtins.str graceful_shutdown_timeout: Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        :param builtins.str hostsystem: vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS
        :param builtins.str memory_size: vSphere size of memory for docker VM (in MB)
        :param Sequence[builtins.str] networks: vSphere network where the virtual machine will be attached
        :param builtins.str password: vSphere password
        :param builtins.str pool: vSphere resource pool for docker VM
        :param builtins.str ssh_password: If using a non-B2D image you can specify the ssh password
        :param builtins.str ssh_port: If using a non-B2D image you can specify the ssh port
        :param builtins.str ssh_user: If using a non-B2D image you can specify the ssh user
        :param builtins.str ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        :param Sequence[builtins.str] tags: vSphere tags id e.g. urn:xxx
        :param builtins.str username: vSphere username
        :param builtins.str vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        :param builtins.str vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        :param Sequence[builtins.str] vapp_properties: vSphere vApp properties
        :param builtins.str vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        :param builtins.str vcenter: vSphere IP/hostname for vCenter
        :param builtins.str vcenter_port: vSphere Port for vCenter
        """
        if boot2docker_url is not None:
            pulumi.set(__self__, "boot2docker_url", boot2docker_url)
        if cfgparams is not None:
            pulumi.set(__self__, "cfgparams", cfgparams)
        if clone_from is not None:
            pulumi.set(__self__, "clone_from", clone_from)
        if cloud_config is not None:
            pulumi.set(__self__, "cloud_config", cloud_config)
        if cloudinit is not None:
            pulumi.set(__self__, "cloudinit", cloudinit)
        if content_library is not None:
            pulumi.set(__self__, "content_library", content_library)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if creation_type is not None:
            pulumi.set(__self__, "creation_type", creation_type)
        if custom_attributes is not None:
            pulumi.set(__self__, "custom_attributes", custom_attributes)
        if datacenter is not None:
            pulumi.set(__self__, "datacenter", datacenter)
        if datastore is not None:
            pulumi.set(__self__, "datastore", datastore)
        if datastore_cluster is not None:
            pulumi.set(__self__, "datastore_cluster", datastore_cluster)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        if hostsystem is not None:
            pulumi.set(__self__, "hostsystem", hostsystem)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if pool is not None:
            pulumi.set(__self__, "pool", pool)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if ssh_user_group is not None:
            pulumi.set(__self__, "ssh_user_group", ssh_user_group)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if vapp_ip_allocation_policy is not None:
            pulumi.set(__self__, "vapp_ip_allocation_policy", vapp_ip_allocation_policy)
        if vapp_ip_protocol is not None:
            pulumi.set(__self__, "vapp_ip_protocol", vapp_ip_protocol)
        if vapp_properties is not None:
            pulumi.set(__self__, "vapp_properties", vapp_properties)
        if vapp_transport is not None:
            pulumi.set(__self__, "vapp_transport", vapp_transport)
        if vcenter is not None:
            pulumi.set(__self__, "vcenter", vcenter)
        if vcenter_port is not None:
            pulumi.set(__self__, "vcenter_port", vcenter_port)

    @property
    @pulumi.getter(name="boot2dockerUrl")
    def boot2docker_url(self) -> Optional[builtins.str]:
        """
        vSphere URL for boot2docker image
        """
        return pulumi.get(self, "boot2docker_url")

    @property
    @pulumi.getter
    def cfgparams(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere vm configuration parameters (used for guestinfo)
        """
        return pulumi.get(self, "cfgparams")

    @property
    @pulumi.getter(name="cloneFrom")
    def clone_from(self) -> Optional[builtins.str]:
        """
        If you choose creation type clone a name of what you want to clone is required
        """
        return pulumi.get(self, "clone_from")

    @property
    @pulumi.getter(name="cloudConfig")
    def cloud_config(self) -> Optional[builtins.str]:
        """
        Filepath to a cloud-config yaml file to put into the ISO user-data
        """
        return pulumi.get(self, "cloud_config")

    @property
    @pulumi.getter
    def cloudinit(self) -> Optional[builtins.str]:
        """
        vSphere cloud-init filepath or url to add to guestinfo
        """
        return pulumi.get(self, "cloudinit")

    @property
    @pulumi.getter(name="contentLibrary")
    def content_library(self) -> Optional[builtins.str]:
        """
        If you choose to clone from a content library template specify the name of the library
        """
        return pulumi.get(self, "content_library")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[builtins.str]:
        """
        vSphere CPU number for docker VM
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="creationType")
    def creation_type(self) -> Optional[builtins.str]:
        """
        Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        """
        return pulumi.get(self, "creation_type")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere custom attributes, format key/value e.g. '200=my custom value'
        """
        return pulumi.get(self, "custom_attributes")

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[builtins.str]:
        """
        vSphere datacenter for virtual machine
        """
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def datastore(self) -> Optional[builtins.str]:
        """
        vSphere datastore for virtual machine
        """
        return pulumi.get(self, "datastore")

    @property
    @pulumi.getter(name="datastoreCluster")
    def datastore_cluster(self) -> Optional[builtins.str]:
        """
        vSphere datastore cluster for virtual machine
        """
        return pulumi.get(self, "datastore_cluster")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[builtins.str]:
        """
        vSphere size of disk for docker VM (in MB)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        """
        vSphere folder for the docker VM. This folder must already exist in the datacenter
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[builtins.str]:
        """
        Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        """
        return pulumi.get(self, "graceful_shutdown_timeout")

    @property
    @pulumi.getter
    def hostsystem(self) -> Optional[builtins.str]:
        """
        vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS
        """
        return pulumi.get(self, "hostsystem")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[builtins.str]:
        """
        vSphere size of memory for docker VM (in MB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter
    def networks(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere network where the virtual machine will be attached
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        """
        vSphere password
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def pool(self) -> Optional[builtins.str]:
        """
        vSphere resource pool for docker VM
        """
        return pulumi.get(self, "pool")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image you can specify the ssh password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image you can specify the ssh port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image you can specify the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="sshUserGroup")
    def ssh_user_group(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        """
        return pulumi.get(self, "ssh_user_group")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere tags id e.g. urn:xxx
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def username(self) -> Optional[builtins.str]:
        """
        vSphere username
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vappIpAllocationPolicy")
    def vapp_ip_allocation_policy(self) -> Optional[builtins.str]:
        """
        vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        """
        return pulumi.get(self, "vapp_ip_allocation_policy")

    @property
    @pulumi.getter(name="vappIpProtocol")
    def vapp_ip_protocol(self) -> Optional[builtins.str]:
        """
        vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        """
        return pulumi.get(self, "vapp_ip_protocol")

    @property
    @pulumi.getter(name="vappProperties")
    def vapp_properties(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere vApp properties
        """
        return pulumi.get(self, "vapp_properties")

    @property
    @pulumi.getter(name="vappTransport")
    def vapp_transport(self) -> Optional[builtins.str]:
        """
        vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        """
        return pulumi.get(self, "vapp_transport")

    @property
    @pulumi.getter
    def vcenter(self) -> Optional[builtins.str]:
        """
        vSphere IP/hostname for vCenter
        """
        return pulumi.get(self, "vcenter")

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[builtins.str]:
        """
        vSphere Port for vCenter
        """
        return pulumi.get(self, "vcenter_port")


@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[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None):
        """
        :param builtins.str limits_cpu: Limit for limits cpu in namespace (string)
        :param builtins.str limits_memory: Limit for limits memory in namespace (string)
        :param builtins.str requests_cpu: Limit for requests cpu in namespace (string)
        :param builtins.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[builtins.str]:
        """
        Limit for limits cpu in namespace (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        """
        Limit for limits memory in namespace (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        """
        Limit for requests cpu in namespace (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.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[builtins.str] = None,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 persistent_volume_claims: Optional[builtins.str] = None,
                 pods: Optional[builtins.str] = None,
                 replication_controllers: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None,
                 requests_storage: Optional[builtins.str] = None,
                 secrets: Optional[builtins.str] = None,
                 services: Optional[builtins.str] = None,
                 services_load_balancers: Optional[builtins.str] = None,
                 services_node_ports: Optional[builtins.str] = None):
        """
        :param builtins.str config_maps: Limit for config maps in namespace (string)
        :param builtins.str limits_cpu: Limit for limits cpu in namespace (string)
        :param builtins.str limits_memory: Limit for limits memory in namespace (string)
        :param builtins.str persistent_volume_claims: Limit for persistent volume claims in namespace (string)
        :param builtins.str pods: Limit for pods in namespace (string)
        :param builtins.str replication_controllers: Limit for replication controllers in namespace (string)
        :param builtins.str requests_cpu: Limit for requests cpu in namespace (string)
        :param builtins.str requests_memory: Limit for requests memory in namespace (string)
        :param builtins.str requests_storage: Limit for requests storage in namespace (string)
        :param builtins.str secrets: Limit for secrets in namespace (string)
        :param builtins.str services_load_balancers: Limit for services load balancers in namespace (string)
        :param builtins.str services_node_ports: Limit for services node ports in namespace (string)
               
               More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
        """
        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[builtins.str]:
        """
        Limit for config maps in namespace (string)
        """
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[builtins.str]:
        """
        Limit for limits cpu in namespace (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.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[builtins.str]:
        """
        Limit for persistent volume claims in namespace (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[builtins.str]:
        """
        Limit for pods in namespace (string)
        """
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[builtins.str]:
        """
        Limit for replication controllers in namespace (string)
        """
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        """
        Limit for requests cpu in namespace (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        """
        Limit for requests memory in namespace (string)
        """
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[builtins.str]:
        """
        Limit for requests storage in namespace (string)
        """
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[builtins.str]:
        """
        Limit for secrets in namespace (string)
        """
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[builtins.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[builtins.str]:
        """
        Limit for services node ports in namespace (string)

        More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
        """
        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: builtins.str,
                 value: builtins.str,
                 effect: Optional[builtins.str] = None,
                 time_added: Optional[builtins.str] = None):
        """
        :param builtins.str key: Taint key (string)
        :param builtins.str value: Taint value (string)
        :param builtins.str effect: Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        :param builtins.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) -> builtins.str:
        """
        Taint key (string)
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        Taint value (string)
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        """
        Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> Optional[builtins.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 == "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 == "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: builtins.str,
                 region: builtins.str,
                 security_groups: Sequence[builtins.str],
                 subnet_id: builtins.str,
                 vpc_id: builtins.str,
                 zone: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 block_duration_minutes: Optional[builtins.str] = None,
                 device_name: Optional[builtins.str] = None,
                 encrypt_ebs_volume: Optional[builtins.bool] = None,
                 endpoint: Optional[builtins.str] = None,
                 http_endpoint: Optional[builtins.str] = None,
                 http_tokens: Optional[builtins.str] = None,
                 iam_instance_profile: Optional[builtins.str] = None,
                 insecure_transport: Optional[builtins.bool] = None,
                 instance_type: Optional[builtins.str] = None,
                 kms_key: Optional[builtins.str] = None,
                 monitoring: Optional[builtins.bool] = None,
                 open_ports: Optional[Sequence[builtins.str]] = None,
                 private_address_only: Optional[builtins.bool] = None,
                 request_spot_instance: Optional[builtins.bool] = None,
                 retries: Optional[builtins.str] = None,
                 root_size: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.str] = None,
                 security_group_readonly: Optional[builtins.bool] = None,
                 session_token: Optional[builtins.str] = None,
                 spot_price: Optional[builtins.str] = None,
                 ssh_keypath: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 use_ebs_optimized_instance: Optional[builtins.bool] = None,
                 use_private_address: Optional[builtins.bool] = None,
                 userdata: Optional[builtins.str] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.str ami: AWS machine image
        :param builtins.str region: AWS Region
        :param Sequence[builtins.str] security_groups: AWS VPC security group
        :param builtins.str subnet_id: AWS VPC subnet id
        :param builtins.str vpc_id: AWS VPC id
        :param builtins.str zone: AWS zone for instance (i.e. a,b,c,d,e)
        :param builtins.str access_key: AWS Access Key
        :param builtins.str block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        :param builtins.str device_name: AWS root device name
        :param builtins.bool encrypt_ebs_volume: Encrypt EBS volume
        :param builtins.str endpoint: Optional endpoint URL (hostname only or fully qualified URI)
        :param builtins.str http_endpoint: Enables or disables the HTTP metadata endpoint on your instances
        :param builtins.str http_tokens: The state of token usage for your instance metadata requests
        :param builtins.str iam_instance_profile: AWS IAM Instance Profile
        :param builtins.bool insecure_transport: Disable SSL when sending requests
        :param builtins.str instance_type: AWS instance type
        :param builtins.str kms_key: Custom KMS key ID using the AWS Managed CMK
        :param builtins.bool monitoring: Set this flag to enable CloudWatch monitoring
        :param Sequence[builtins.str] open_ports: Make the specified port number accessible from the Internet
        :param builtins.bool private_address_only: Only use a private IP address
        :param builtins.bool request_spot_instance: Set this flag to request spot instance
        :param builtins.str retries: Set retry count for recoverable failures (use -1 to disable)
        :param builtins.str root_size: AWS root disk size (in GB)
        :param builtins.str secret_key: AWS Secret Key
        :param builtins.bool security_group_readonly: Skip adding default rules to security groups
        :param builtins.str session_token: AWS Session Token
        :param builtins.str spot_price: AWS spot instance bid price (in dollar)
        :param builtins.str ssh_keypath: SSH Key for Instance
        :param builtins.str ssh_user: Set the name of the ssh user
        :param builtins.str tags: AWS Tags (e.g. key1,value1,key2,value2)
        :param builtins.bool use_ebs_optimized_instance: Create an EBS optimized instance
        :param builtins.bool use_private_address: Force the usage of private IP address
        :param builtins.str userdata: Path to file with cloud-init user data
        :param builtins.str volume_type: Amazon EBS volume type
        """
        pulumi.set(__self__, "ami", ami)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "security_groups", security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "zone", zone)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if encrypt_ebs_volume is not None:
            pulumi.set(__self__, "encrypt_ebs_volume", encrypt_ebs_volume)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if http_tokens is not None:
            pulumi.set(__self__, "http_tokens", http_tokens)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if insecure_transport is not None:
            pulumi.set(__self__, "insecure_transport", insecure_transport)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if kms_key is not None:
            pulumi.set(__self__, "kms_key", kms_key)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if private_address_only is not None:
            pulumi.set(__self__, "private_address_only", private_address_only)
        if request_spot_instance is not None:
            pulumi.set(__self__, "request_spot_instance", request_spot_instance)
        if retries is not None:
            pulumi.set(__self__, "retries", retries)
        if root_size is not None:
            pulumi.set(__self__, "root_size", root_size)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)
        if security_group_readonly is not None:
            pulumi.set(__self__, "security_group_readonly", security_group_readonly)
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if ssh_keypath is not None:
            pulumi.set(__self__, "ssh_keypath", ssh_keypath)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if use_ebs_optimized_instance is not None:
            pulumi.set(__self__, "use_ebs_optimized_instance", use_ebs_optimized_instance)
        if use_private_address is not None:
            pulumi.set(__self__, "use_private_address", use_private_address)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def ami(self) -> builtins.str:
        """
        AWS machine image
        """
        return pulumi.get(self, "ami")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        """
        AWS Region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Sequence[builtins.str]:
        """
        AWS VPC security group
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        AWS VPC subnet id
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        AWS VPC id
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter
    def zone(self) -> builtins.str:
        """
        AWS zone for instance (i.e. a,b,c,d,e)
        """
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[builtins.str]:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[builtins.str]:
        """
        AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        """
        return pulumi.get(self, "block_duration_minutes")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[builtins.str]:
        """
        AWS root device name
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="encryptEbsVolume")
    def encrypt_ebs_volume(self) -> Optional[builtins.bool]:
        """
        Encrypt EBS volume
        """
        return pulumi.get(self, "encrypt_ebs_volume")

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[builtins.str]:
        """
        Optional endpoint URL (hostname only or fully qualified URI)
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="httpEndpoint")
    def http_endpoint(self) -> Optional[builtins.str]:
        """
        Enables or disables the HTTP metadata endpoint on your instances
        """
        return pulumi.get(self, "http_endpoint")

    @property
    @pulumi.getter(name="httpTokens")
    def http_tokens(self) -> Optional[builtins.str]:
        """
        The state of token usage for your instance metadata requests
        """
        return pulumi.get(self, "http_tokens")

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional[builtins.str]:
        """
        AWS IAM Instance Profile
        """
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="insecureTransport")
    def insecure_transport(self) -> Optional[builtins.bool]:
        """
        Disable SSL when sending requests
        """
        return pulumi.get(self, "insecure_transport")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        AWS instance type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[builtins.str]:
        """
        Custom KMS key ID using the AWS Managed CMK
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[builtins.bool]:
        """
        Set this flag to enable CloudWatch monitoring
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[Sequence[builtins.str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[builtins.bool]:
        """
        Only use a private IP address
        """
        return pulumi.get(self, "private_address_only")

    @property
    @pulumi.getter(name="requestSpotInstance")
    def request_spot_instance(self) -> Optional[builtins.bool]:
        """
        Set this flag to request spot instance
        """
        return pulumi.get(self, "request_spot_instance")

    @property
    @pulumi.getter
    def retries(self) -> Optional[builtins.str]:
        """
        Set retry count for recoverable failures (use -1 to disable)
        """
        return pulumi.get(self, "retries")

    @property
    @pulumi.getter(name="rootSize")
    def root_size(self) -> Optional[builtins.str]:
        """
        AWS root disk size (in GB)
        """
        return pulumi.get(self, "root_size")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.str]:
        """
        AWS Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="securityGroupReadonly")
    def security_group_readonly(self) -> Optional[builtins.bool]:
        """
        Skip adding default rules to security groups
        """
        return pulumi.get(self, "security_group_readonly")

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[builtins.str]:
        """
        AWS Session Token
        """
        return pulumi.get(self, "session_token")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[builtins.str]:
        """
        AWS spot instance bid price (in dollar)
        """
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="sshKeypath")
    def ssh_keypath(self) -> Optional[builtins.str]:
        """
        SSH Key for Instance
        """
        return pulumi.get(self, "ssh_keypath")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        Set the name of the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        AWS Tags (e.g. key1,value1,key2,value2)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="useEbsOptimizedInstance")
    def use_ebs_optimized_instance(self) -> Optional[builtins.bool]:
        """
        Create an EBS optimized instance
        """
        return pulumi.get(self, "use_ebs_optimized_instance")

    @property
    @pulumi.getter(name="usePrivateAddress")
    def use_private_address(self) -> Optional[builtins.bool]:
        """
        Force the usage of private IP address
        """
        return pulumi.get(self, "use_private_address")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[builtins.str]:
        """
        Path to file with cloud-init user data
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[builtins.str]:
        """
        Amazon EBS volume type
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class NodeTemplateAzureConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acceleratedNetworking":
            suggest = "accelerated_networking"
        elif key == "availabilitySet":
            suggest = "availability_set"
        elif key == "availabilityZone":
            suggest = "availability_zone"
        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"
        elif key == "usePublicIpStandardSku":
            suggest = "use_public_ip_standard_sku"

        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__, *,
                 accelerated_networking: Optional[builtins.bool] = None,
                 availability_set: Optional[builtins.str] = None,
                 availability_zone: Optional[builtins.str] = None,
                 client_id: Optional[builtins.str] = None,
                 client_secret: Optional[builtins.str] = None,
                 custom_data: Optional[builtins.str] = None,
                 disk_size: Optional[builtins.str] = None,
                 dns: Optional[builtins.str] = None,
                 docker_port: Optional[builtins.str] = None,
                 environment: Optional[builtins.str] = None,
                 fault_domain_count: Optional[builtins.str] = None,
                 image: Optional[builtins.str] = None,
                 location: Optional[builtins.str] = None,
                 managed_disks: Optional[builtins.bool] = None,
                 no_public_ip: Optional[builtins.bool] = None,
                 nsg: Optional[builtins.str] = None,
                 open_ports: Optional[Sequence[builtins.str]] = None,
                 plan: Optional[builtins.str] = None,
                 private_ip_address: Optional[builtins.str] = None,
                 resource_group: Optional[builtins.str] = None,
                 size: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 static_public_ip: Optional[builtins.bool] = None,
                 storage_type: Optional[builtins.str] = None,
                 subnet: Optional[builtins.str] = None,
                 subnet_prefix: Optional[builtins.str] = None,
                 subscription_id: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 update_domain_count: Optional[builtins.str] = None,
                 use_private_ip: Optional[builtins.bool] = None,
                 use_public_ip_standard_sku: Optional[builtins.bool] = None,
                 vnet: Optional[builtins.str] = None):
        """
        :param builtins.bool accelerated_networking: Enable Accelerated Networking when creating an Azure Network Interface
        :param builtins.str availability_set: Azure Availability Set to place the virtual machine into
        :param builtins.str availability_zone: The Azure Availability Zone the VM should be created in
        :param builtins.str client_id: Azure Service Principal Account ID (optional, browser auth is used if not specified)
        :param builtins.str client_secret: Azure Service Principal Account password (optional, browser auth is used if not specified)
        :param builtins.str custom_data: Path to file with custom-data
        :param builtins.str disk_size: Disk size if using managed disk
        :param builtins.str dns: A unique DNS label for the public IP adddress
        :param builtins.str docker_port: Port number for Docker engine
        :param builtins.str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param builtins.str fault_domain_count: Fault domain count to use for availability set
        :param builtins.str image: Azure virtual machine OS image
        :param builtins.str location: Azure region to create the virtual machine
        :param builtins.bool managed_disks: Configures VM and availability set for managed disks
        :param builtins.bool no_public_ip: Do not create a public IP address for the machine
        :param builtins.str nsg: Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine)
        :param Sequence[builtins.str] open_ports: Make the specified port number accessible from the Internet
        :param builtins.str plan: Purchase plan for Azure Virtual Machine (in <publisher>:<product>:<plan> format)
        :param builtins.str private_ip_address: Specify a static private IP address for the machine
        :param builtins.str resource_group: Azure Resource Group name (will be created if missing)
        :param builtins.str size: Size for Azure Virtual Machine
        :param builtins.str ssh_user: Username for SSH login
        :param builtins.bool static_public_ip: Assign a static public IP address to the machine
        :param builtins.str storage_type: Type of Storage Account to host the OS Disk for the machine
        :param builtins.str subnet: Azure Subnet Name to be used within the Virtual Network
        :param builtins.str subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918
        :param builtins.str subscription_id: Azure Subscription ID
        :param builtins.str tags: Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        :param builtins.str update_domain_count: Update domain count to use for availability set
        :param builtins.bool use_private_ip: Use private IP address of the machine to connect
        :param builtins.bool use_public_ip_standard_sku: Use the Standard SKU when creating a public IP for an Azure VM
        :param builtins.str vnet: Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        if accelerated_networking is not None:
            pulumi.set(__self__, "accelerated_networking", accelerated_networking)
        if availability_set is not None:
            pulumi.set(__self__, "availability_set", availability_set)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if custom_data is not None:
            pulumi.set(__self__, "custom_data", custom_data)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if fault_domain_count is not None:
            pulumi.set(__self__, "fault_domain_count", fault_domain_count)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if managed_disks is not None:
            pulumi.set(__self__, "managed_disks", managed_disks)
        if no_public_ip is not None:
            pulumi.set(__self__, "no_public_ip", no_public_ip)
        if nsg is not None:
            pulumi.set(__self__, "nsg", nsg)
        if open_ports is not None:
            pulumi.set(__self__, "open_ports", open_ports)
        if plan is not None:
            pulumi.set(__self__, "plan", plan)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if static_public_ip is not None:
            pulumi.set(__self__, "static_public_ip", static_public_ip)
        if storage_type is not None:
            pulumi.set(__self__, "storage_type", storage_type)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if subnet_prefix is not None:
            pulumi.set(__self__, "subnet_prefix", subnet_prefix)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if update_domain_count is not None:
            pulumi.set(__self__, "update_domain_count", update_domain_count)
        if use_private_ip is not None:
            pulumi.set(__self__, "use_private_ip", use_private_ip)
        if use_public_ip_standard_sku is not None:
            pulumi.set(__self__, "use_public_ip_standard_sku", use_public_ip_standard_sku)
        if vnet is not None:
            pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="acceleratedNetworking")
    def accelerated_networking(self) -> Optional[builtins.bool]:
        """
        Enable Accelerated Networking when creating an Azure Network Interface
        """
        return pulumi.get(self, "accelerated_networking")

    @property
    @pulumi.getter(name="availabilitySet")
    def availability_set(self) -> Optional[builtins.str]:
        """
        Azure Availability Set to place the virtual machine into
        """
        return pulumi.get(self, "availability_set")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[builtins.str]:
        """
        The Azure Availability Zone the VM should be created in
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[builtins.str]:
        """
        Azure Service Principal Account ID (optional, browser auth is used if not specified)
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[builtins.str]:
        """
        Azure Service Principal Account password (optional, browser auth is used if not specified)
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="customData")
    def custom_data(self) -> Optional[builtins.str]:
        """
        Path to file with custom-data
        """
        return pulumi.get(self, "custom_data")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[builtins.str]:
        """
        Disk size if using managed disk
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def dns(self) -> Optional[builtins.str]:
        """
        A unique DNS label for the public IP adddress
        """
        return pulumi.get(self, "dns")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[builtins.str]:
        """
        Port number for Docker engine
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def environment(self) -> Optional[builtins.str]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="faultDomainCount")
    def fault_domain_count(self) -> Optional[builtins.str]:
        """
        Fault domain count to use for availability set
        """
        return pulumi.get(self, "fault_domain_count")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Azure virtual machine OS image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def location(self) -> Optional[builtins.str]:
        """
        Azure region to create the virtual machine
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="managedDisks")
    def managed_disks(self) -> Optional[builtins.bool]:
        """
        Configures VM and availability set for managed disks
        """
        return pulumi.get(self, "managed_disks")

    @property
    @pulumi.getter(name="noPublicIp")
    def no_public_ip(self) -> Optional[builtins.bool]:
        """
        Do not create a public IP address for the machine
        """
        return pulumi.get(self, "no_public_ip")

    @property
    @pulumi.getter
    def nsg(self) -> Optional[builtins.str]:
        """
        Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine)
        """
        return pulumi.get(self, "nsg")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[Sequence[builtins.str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter
    def plan(self) -> Optional[builtins.str]:
        """
        Purchase plan for Azure Virtual Machine (in <publisher>:<product>:<plan> format)
        """
        return pulumi.get(self, "plan")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[builtins.str]:
        """
        Specify a static private IP address for the machine
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[builtins.str]:
        """
        Azure Resource Group name (will be created if missing)
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.str]:
        """
        Size for Azure Virtual Machine
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        Username for SSH login
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="staticPublicIp")
    def static_public_ip(self) -> Optional[builtins.bool]:
        """
        Assign a static public IP address to the machine
        """
        return pulumi.get(self, "static_public_ip")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[builtins.str]:
        """
        Type of Storage Account to host the OS Disk for the machine
        """
        return pulumi.get(self, "storage_type")

    @property
    @pulumi.getter
    def subnet(self) -> Optional[builtins.str]:
        """
        Azure Subnet Name to be used within the Virtual Network
        """
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter(name="subnetPrefix")
    def subnet_prefix(self) -> Optional[builtins.str]:
        """
        Private CIDR block to be used for the new subnet, should comply RFC 1918
        """
        return pulumi.get(self, "subnet_prefix")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[builtins.str]:
        """
        Azure Subscription ID
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="updateDomainCount")
    def update_domain_count(self) -> Optional[builtins.str]:
        """
        Update domain count to use for availability set
        """
        return pulumi.get(self, "update_domain_count")

    @property
    @pulumi.getter(name="usePrivateIp")
    def use_private_ip(self) -> Optional[builtins.bool]:
        """
        Use private IP address of the machine to connect
        """
        return pulumi.get(self, "use_private_ip")

    @property
    @pulumi.getter(name="usePublicIpStandardSku")
    def use_public_ip_standard_sku(self) -> Optional[builtins.bool]:
        """
        Use the Standard SKU when creating a public IP for an Azure VM
        """
        return pulumi.get(self, "use_public_ip_standard_sku")

    @property
    @pulumi.getter
    def vnet(self) -> Optional[builtins.str]:
        """
        Azure Virtual Network name to connect the virtual machine (in [resourcegroup:]name format)
        """
        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[builtins.str] = None,
                 backups: Optional[builtins.bool] = None,
                 image: Optional[builtins.str] = None,
                 ipv6: Optional[builtins.bool] = None,
                 monitoring: Optional[builtins.bool] = None,
                 private_networking: Optional[builtins.bool] = None,
                 region: Optional[builtins.str] = None,
                 size: Optional[builtins.str] = None,
                 ssh_key_fingerprint: Optional[builtins.str] = None,
                 ssh_key_path: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 userdata: Optional[builtins.str] = None):
        """
        :param builtins.str access_token: Digital Ocean access token
        :param builtins.bool backups: Enable backups for droplet
        :param builtins.str image: Digital Ocean Image
        :param builtins.bool ipv6: Enable ipv6 for droplet
        :param builtins.bool monitoring: Enable monitoring for droplet
        :param builtins.bool private_networking: Enable private networking for droplet
        :param builtins.str region: Digital Ocean region
        :param builtins.str size: Digital Ocean size
        :param builtins.str ssh_key_fingerprint: SSH key fingerprint
        :param builtins.str ssh_key_path: SSH private key path
        :param builtins.str ssh_port: SSH port
        :param builtins.str ssh_user: SSH username
        :param builtins.str tags: Comma-separated list of tags to apply to the Droplet
        :param builtins.str userdata: Path to file with cloud-init user-data
        """
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if backups is not None:
            pulumi.set(__self__, "backups", backups)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if private_networking is not None:
            pulumi.set(__self__, "private_networking", private_networking)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if ssh_key_fingerprint is not None:
            pulumi.set(__self__, "ssh_key_fingerprint", ssh_key_fingerprint)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[builtins.str]:
        """
        Digital Ocean access token
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter
    def backups(self) -> Optional[builtins.bool]:
        """
        Enable backups for droplet
        """
        return pulumi.get(self, "backups")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Digital Ocean Image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[builtins.bool]:
        """
        Enable ipv6 for droplet
        """
        return pulumi.get(self, "ipv6")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[builtins.bool]:
        """
        Enable monitoring for droplet
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="privateNetworking")
    def private_networking(self) -> Optional[builtins.bool]:
        """
        Enable private networking for droplet
        """
        return pulumi.get(self, "private_networking")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        Digital Ocean region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.str]:
        """
        Digital Ocean size
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[builtins.str]:
        """
        SSH key fingerprint
        """
        return pulumi.get(self, "ssh_key_fingerprint")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[builtins.str]:
        """
        SSH private key path
        """
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[builtins.str]:
        """
        SSH port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        Comma-separated list of tags to apply to the Droplet
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[builtins.str]:
        """
        Path to file with cloud-init user-data
        """
        return pulumi.get(self, "userdata")


@pulumi.output_type
class NodeTemplateHarvesterConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sshUser":
            suggest = "ssh_user"
        elif key == "vmNamespace":
            suggest = "vm_namespace"
        elif key == "cpuCount":
            suggest = "cpu_count"
        elif key == "diskBus":
            suggest = "disk_bus"
        elif key == "diskInfo":
            suggest = "disk_info"
        elif key == "diskSize":
            suggest = "disk_size"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "memorySize":
            suggest = "memory_size"
        elif key == "networkData":
            suggest = "network_data"
        elif key == "networkInfo":
            suggest = "network_info"
        elif key == "networkModel":
            suggest = "network_model"
        elif key == "networkName":
            suggest = "network_name"
        elif key == "sshPassword":
            suggest = "ssh_password"
        elif key == "userData":
            suggest = "user_data"
        elif key == "vmAffinity":
            suggest = "vm_affinity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateHarvesterConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateHarvesterConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateHarvesterConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ssh_user: builtins.str,
                 vm_namespace: builtins.str,
                 cpu_count: Optional[builtins.str] = None,
                 disk_bus: Optional[builtins.str] = None,
                 disk_info: Optional[builtins.str] = None,
                 disk_size: Optional[builtins.str] = None,
                 image_name: Optional[builtins.str] = None,
                 memory_size: Optional[builtins.str] = None,
                 network_data: Optional[builtins.str] = None,
                 network_info: Optional[builtins.str] = None,
                 network_model: Optional[builtins.str] = None,
                 network_name: Optional[builtins.str] = None,
                 ssh_password: Optional[builtins.str] = None,
                 user_data: Optional[builtins.str] = None,
                 vm_affinity: Optional[builtins.str] = None):
        """
        :param builtins.str ssh_user: SSH username
        :param builtins.str vm_namespace: Virtual machine namespace
        :param builtins.str cpu_count: CPU count
        :param builtins.str disk_bus: Disk bus
        :param builtins.str disk_info: A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        :param builtins.str disk_size: Disk size (in GiB)
        :param builtins.str image_name: Image name
        :param builtins.str memory_size: Memory size (in GiB)
        :param builtins.str network_data: NetworkData content of cloud-init, base64 is supported
        :param builtins.str network_info: A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        :param builtins.str network_model: Network model
        :param builtins.str network_name: Network name
        :param builtins.str ssh_password: SSH password
        :param builtins.str user_data: UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        :param builtins.str vm_affinity: VM affinity, base64 is supported
        """
        pulumi.set(__self__, "ssh_user", ssh_user)
        pulumi.set(__self__, "vm_namespace", vm_namespace)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if disk_bus is not None:
            pulumi.set(__self__, "disk_bus", disk_bus)
        if disk_info is not None:
            pulumi.set(__self__, "disk_info", disk_info)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if network_data is not None:
            pulumi.set(__self__, "network_data", network_data)
        if network_info is not None:
            pulumi.set(__self__, "network_info", network_info)
        if network_model is not None:
            pulumi.set(__self__, "network_model", network_model)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if vm_affinity is not None:
            pulumi.set(__self__, "vm_affinity", vm_affinity)

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> builtins.str:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="vmNamespace")
    def vm_namespace(self) -> builtins.str:
        """
        Virtual machine namespace
        """
        return pulumi.get(self, "vm_namespace")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[builtins.str]:
        """
        CPU count
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="diskBus")
    @_utilities.deprecated("""Use disk_info instead""")
    def disk_bus(self) -> Optional[builtins.str]:
        """
        Disk bus
        """
        return pulumi.get(self, "disk_bus")

    @property
    @pulumi.getter(name="diskInfo")
    def disk_info(self) -> Optional[builtins.str]:
        """
        A JSON string specifying info for the disks e.g. `{"disks":[{"imageName":"harvester-public/image-57hzg","bootOrder":1,"size":40},{"storageClassName":"node-driver-test","bootOrder":2,"size":1}]}`
        """
        return pulumi.get(self, "disk_info")

    @property
    @pulumi.getter(name="diskSize")
    @_utilities.deprecated("""Use disk_info instead""")
    def disk_size(self) -> Optional[builtins.str]:
        """
        Disk size (in GiB)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter(name="imageName")
    @_utilities.deprecated("""Use disk_info instead""")
    def image_name(self) -> Optional[builtins.str]:
        """
        Image name
        """
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[builtins.str]:
        """
        Memory size (in GiB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter(name="networkData")
    def network_data(self) -> Optional[builtins.str]:
        """
        NetworkData content of cloud-init, base64 is supported
        """
        return pulumi.get(self, "network_data")

    @property
    @pulumi.getter(name="networkInfo")
    def network_info(self) -> Optional[builtins.str]:
        """
        A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        """
        return pulumi.get(self, "network_info")

    @property
    @pulumi.getter(name="networkModel")
    @_utilities.deprecated("""Use network_info instead""")
    def network_model(self) -> Optional[builtins.str]:
        """
        Network model
        """
        return pulumi.get(self, "network_model")

    @property
    @pulumi.getter(name="networkName")
    @_utilities.deprecated("""Use network_info instead""")
    def network_name(self) -> Optional[builtins.str]:
        """
        Network name
        """
        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[builtins.str]:
        """
        SSH password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[builtins.str]:
        """
        UserData content of cloud-init, base64 is supported. If the image does not contain the qemu-guest-agent package, you must install and start qemu-guest-agent using userdata
        """
        return pulumi.get(self, "user_data")

    @property
    @pulumi.getter(name="vmAffinity")
    def vm_affinity(self) -> Optional[builtins.str]:
        """
        VM affinity, base64 is supported
        """
        return pulumi.get(self, "vm_affinity")


@pulumi.output_type
class NodeTemplateHetznerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiToken":
            suggest = "api_token"
        elif key == "serverLabels":
            suggest = "server_labels"
        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: builtins.str,
                 image: Optional[builtins.str] = None,
                 networks: Optional[builtins.str] = None,
                 server_labels: Optional[Mapping[str, builtins.str]] = None,
                 server_location: Optional[builtins.str] = None,
                 server_type: Optional[builtins.str] = None,
                 use_private_network: Optional[builtins.bool] = None,
                 userdata: Optional[builtins.str] = None,
                 volumes: Optional[builtins.str] = None):
        """
        :param builtins.str api_token: Hetzner Cloud project API token
        :param builtins.str image: Hetzner Cloud server image
        :param builtins.str networks: Comma-separated list of network IDs or names which should be attached to the server private network interface
        :param Mapping[str, builtins.str] server_labels: Map of the labels which will be assigned to the server
        :param builtins.str server_location: Hetzner Cloud datacenter
        :param builtins.str server_type: Hetzner Cloud server type
        :param builtins.bool use_private_network: Use private network
        :param builtins.str userdata: Path to file with cloud-init user-data
        :param builtins.str volumes: Comma-separated list of volume IDs or names which should be attached to the server
        """
        pulumi.set(__self__, "api_token", api_token)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if server_labels is not None:
            pulumi.set(__self__, "server_labels", server_labels)
        if server_location is not None:
            pulumi.set(__self__, "server_location", server_location)
        if server_type is not None:
            pulumi.set(__self__, "server_type", server_type)
        if use_private_network is not None:
            pulumi.set(__self__, "use_private_network", use_private_network)
        if userdata is not None:
            pulumi.set(__self__, "userdata", userdata)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)

    @property
    @pulumi.getter(name="apiToken")
    def api_token(self) -> builtins.str:
        """
        Hetzner Cloud project API token
        """
        return pulumi.get(self, "api_token")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Hetzner Cloud server image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def networks(self) -> Optional[builtins.str]:
        """
        Comma-separated list of network IDs or names which should be attached to the server private network interface
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter(name="serverLabels")
    def server_labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Map of the labels which will be assigned to the server
        """
        return pulumi.get(self, "server_labels")

    @property
    @pulumi.getter(name="serverLocation")
    def server_location(self) -> Optional[builtins.str]:
        """
        Hetzner Cloud datacenter
        """
        return pulumi.get(self, "server_location")

    @property
    @pulumi.getter(name="serverType")
    def server_type(self) -> Optional[builtins.str]:
        """
        Hetzner Cloud server type
        """
        return pulumi.get(self, "server_type")

    @property
    @pulumi.getter(name="usePrivateNetwork")
    def use_private_network(self) -> Optional[builtins.bool]:
        """
        Use private network
        """
        return pulumi.get(self, "use_private_network")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[builtins.str]:
        """
        Path to file with cloud-init user-data
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter
    def volumes(self) -> Optional[builtins.str]:
        """
        Comma-separated list of volume IDs or names which should be attached to the server
        """
        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[builtins.str] = None,
                 create_private_ip: Optional[builtins.bool] = None,
                 docker_port: Optional[builtins.str] = None,
                 image: Optional[builtins.str] = None,
                 instance_type: Optional[builtins.str] = None,
                 label: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 root_pass: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 stackscript: Optional[builtins.str] = None,
                 stackscript_data: Optional[builtins.str] = None,
                 swap_size: Optional[builtins.str] = None,
                 tags: Optional[builtins.str] = None,
                 token: Optional[builtins.str] = None,
                 ua_prefix: Optional[builtins.str] = None):
        """
        :param builtins.str authorized_users: Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node
        :param builtins.bool create_private_ip: Create private IP for the instance
        :param builtins.str docker_port: Docker Port
        :param builtins.str image: Specifies the Linode Instance image which determines the OS distribution and base files
        :param builtins.str instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        :param builtins.str label: Linode Instance Label
        :param builtins.str region: Specifies the region (location) of the Linode instance
        :param builtins.str root_pass: Root Password
        :param builtins.str ssh_port: Linode Instance SSH Port
        :param builtins.str ssh_user: Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        :param builtins.str stackscript: Specifies the Linode StackScript to use to create the instance
        :param builtins.str stackscript_data: A JSON string specifying data for the selected StackScript
        :param builtins.str swap_size: Linode Instance Swap Size (MB)
        :param builtins.str tags: A comma separated list of tags to apply to the the Linode resource
        :param builtins.str token: Linode API Token
        :param builtins.str ua_prefix: Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        if authorized_users is not None:
            pulumi.set(__self__, "authorized_users", authorized_users)
        if create_private_ip is not None:
            pulumi.set(__self__, "create_private_ip", create_private_ip)
        if docker_port is not None:
            pulumi.set(__self__, "docker_port", docker_port)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if root_pass is not None:
            pulumi.set(__self__, "root_pass", root_pass)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if stackscript is not None:
            pulumi.set(__self__, "stackscript", stackscript)
        if stackscript_data is not None:
            pulumi.set(__self__, "stackscript_data", stackscript_data)
        if swap_size is not None:
            pulumi.set(__self__, "swap_size", swap_size)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if ua_prefix is not None:
            pulumi.set(__self__, "ua_prefix", ua_prefix)

    @property
    @pulumi.getter(name="authorizedUsers")
    def authorized_users(self) -> Optional[builtins.str]:
        """
        Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node
        """
        return pulumi.get(self, "authorized_users")

    @property
    @pulumi.getter(name="createPrivateIp")
    def create_private_ip(self) -> Optional[builtins.bool]:
        """
        Create private IP for the instance
        """
        return pulumi.get(self, "create_private_ip")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[builtins.str]:
        """
        Docker Port
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def label(self) -> Optional[builtins.str]:
        """
        Linode Instance Label
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        Specifies the region (location) of the Linode instance
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="rootPass")
    def root_pass(self) -> Optional[builtins.str]:
        """
        Root Password
        """
        return pulumi.get(self, "root_pass")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[builtins.str]:
        """
        Linode Instance SSH Port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def stackscript(self) -> Optional[builtins.str]:
        """
        Specifies the Linode StackScript to use to create the instance
        """
        return pulumi.get(self, "stackscript")

    @property
    @pulumi.getter(name="stackscriptData")
    def stackscript_data(self) -> Optional[builtins.str]:
        """
        A JSON string specifying data for the selected StackScript
        """
        return pulumi.get(self, "stackscript_data")

    @property
    @pulumi.getter(name="swapSize")
    def swap_size(self) -> Optional[builtins.str]:
        """
        Linode Instance Swap Size (MB)
        """
        return pulumi.get(self, "swap_size")

    @property
    @pulumi.getter
    def tags(self) -> Optional[builtins.str]:
        """
        A comma separated list of tags to apply to the the Linode resource
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def token(self) -> Optional[builtins.str]:
        """
        Linode API Token
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="uaPrefix")
    def ua_prefix(self) -> Optional[builtins.str]:
        """
        Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        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: builtins.str,
                 value: builtins.str,
                 effect: Optional[builtins.str] = None,
                 time_added: Optional[builtins.str] = None):
        """
        :param builtins.str key: Taint key (string)
        :param builtins.str value: Taint value (string)
        :param builtins.str effect: Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        :param builtins.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) -> builtins.str:
        """
        Taint key (string)
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        Taint value (string)
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        """
        Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
        """
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> Optional[builtins.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: builtins.str,
                 user: builtins.str,
                 xml_rpc_url: builtins.str,
                 b2d_size: Optional[builtins.str] = None,
                 cpu: Optional[builtins.str] = None,
                 dev_prefix: Optional[builtins.str] = None,
                 disable_vnc: Optional[builtins.bool] = None,
                 disk_resize: Optional[builtins.str] = None,
                 image_id: Optional[builtins.str] = None,
                 image_name: Optional[builtins.str] = None,
                 image_owner: Optional[builtins.str] = None,
                 memory: Optional[builtins.str] = None,
                 network_id: Optional[builtins.str] = None,
                 network_name: Optional[builtins.str] = None,
                 network_owner: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 template_id: Optional[builtins.str] = None,
                 template_name: Optional[builtins.str] = None,
                 vcpu: Optional[builtins.str] = None):
        """
        :param builtins.str password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param builtins.str user: Set the user for the XML-RPC API authentication (string)
        :param builtins.str xml_rpc_url: Set the url for the Opennebula XML-RPC API (string)
        :param builtins.str b2d_size: Size of the Volatile disk in MB - only for b2d (string)
        :param builtins.str cpu: CPU value for the VM (string)
        :param builtins.str dev_prefix: Dev prefix to use for the images. E.g.: 'vd', 'sd', 'hd' (string)
        :param builtins.bool disable_vnc: VNC is enabled by default. Disable it with this flag (bool)
        :param builtins.str disk_resize: Size of the disk for the VM in MB (string)
        :param builtins.str image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param builtins.str image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param builtins.str image_owner: Owner of the image to use as the VM OS (string)
        :param builtins.str memory: Size of the memory for the VM in MB (string)
        :param builtins.str network_id: Opennebula network ID to connect the machine to. Conflicts with `network_name` (string)
        :param builtins.str network_name: Opennebula network to connect the machine to. Conflicts with `network_id` (string)
        :param builtins.str network_owner: Opennebula user ID of the Network to connect the machine to (string)
        :param builtins.str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param builtins.str template_id: Opennebula template ID to use. Conflicts with `template_name` (string)
        :param builtins.str template_name: Name of the Opennbula template to use. Conflicts with `template_id` (string)
        :param builtins.str vcpu: VCPUs for the VM (string)
               
               > **Note:**: `Required*` denotes that one of image_name / image_id or template_name / template_id is required but you cannot combine them.
        """
        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) -> builtins.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) -> builtins.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) -> builtins.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[builtins.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[builtins.str]:
        """
        CPU value for the VM (string)
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="devPrefix")
    def dev_prefix(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.str]:
        """
        VCPUs for the VM (string)

        > **Note:**: `Required*` denotes that one of image_name / image_id or template_name / template_id is required but you cannot combine them.
        """
        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: builtins.str,
                 availability_zone: builtins.str,
                 region: builtins.str,
                 active_timeout: Optional[builtins.str] = None,
                 application_credential_id: Optional[builtins.str] = None,
                 application_credential_name: Optional[builtins.str] = None,
                 application_credential_secret: Optional[builtins.str] = None,
                 boot_from_volume: Optional[builtins.bool] = None,
                 cacert: Optional[builtins.str] = None,
                 config_drive: Optional[builtins.bool] = None,
                 domain_id: Optional[builtins.str] = None,
                 domain_name: Optional[builtins.str] = None,
                 endpoint_type: Optional[builtins.str] = None,
                 flavor_id: Optional[builtins.str] = None,
                 flavor_name: Optional[builtins.str] = None,
                 floating_ip_pool: Optional[builtins.str] = None,
                 image_id: Optional[builtins.str] = None,
                 image_name: Optional[builtins.str] = None,
                 insecure: Optional[builtins.bool] = None,
                 ip_version: Optional[builtins.str] = None,
                 keypair_name: Optional[builtins.str] = None,
                 net_id: Optional[builtins.str] = None,
                 net_name: Optional[builtins.str] = None,
                 nova_network: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 private_key_file: Optional[builtins.str] = None,
                 sec_groups: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 tenant_id: Optional[builtins.str] = None,
                 tenant_name: Optional[builtins.str] = None,
                 user_data_file: Optional[builtins.str] = None,
                 username: Optional[builtins.str] = None,
                 volume_device_path: Optional[builtins.str] = None,
                 volume_id: Optional[builtins.str] = None,
                 volume_name: Optional[builtins.str] = None,
                 volume_size: Optional[builtins.str] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.str auth_url: OpenStack authentication URL (string)
        :param builtins.str availability_zone: OpenStack availability zone (string)
        :param builtins.str region: AWS region. Default `eu-west-2` (string)
        :param builtins.str active_timeout: OpenStack active timeout Default `200` (string)
        :param builtins.str application_credential_id: OpenStack application credential id. Conflicts with `application_credential_name` (string)
        :param builtins.str application_credential_name: OpenStack application credential name. Conflicts with `application_credential_id` (string)
        :param builtins.str application_credential_secret: OpenStack application credential secret (string)
        :param builtins.bool boot_from_volume: Enable booting from volume. Default is `false` (bool)
        :param builtins.str cacert: CA certificate bundle to verify against (string)
        :param builtins.bool config_drive: Enables the OpenStack config drive for the instance. Default `false` (bool)
        :param builtins.str domain_id: OpenStack domain ID. Identity v3 only. Conflicts with `domain_name` (string)
        :param builtins.str domain_name: OpenStack domain name. Identity v3 only. Conflicts with `domain_id` (string)
        :param builtins.str endpoint_type: OpenStack endpoint type. adminURL, internalURL or publicURL (string)
        :param builtins.str flavor_id: OpenStack flavor id to use for the instance. Conflicts with `flavor_name` (string)
        :param builtins.str flavor_name: OpenStack flavor name to use for the instance. Conflicts with `flavor_id` (string)
        :param builtins.str floating_ip_pool: OpenStack floating IP pool to get an IP from to assign to the instance (string)
        :param builtins.str image_id: OpenStack image id to use for the instance. Conflicts with `image_name` (string)
        :param builtins.str image_name: OpenStack image name to use for the instance. Conflicts with `image_id` (string)
        :param builtins.bool insecure: Disable TLS credential checking. Default `false` (bool)
        :param builtins.str ip_version: OpenStack version of IP address assigned for the machine Default `4` (string)
        :param builtins.str keypair_name: OpenStack keypair to use to SSH to the instance (string)
        :param builtins.str net_id: OpenStack network id the machine will be connected on. Conflicts with `net_name` (string)
        :param builtins.str net_name: OpenStack network name the machine will be connected on. Conflicts with `net_id` (string)
        :param builtins.bool nova_network: Use the nova networking services instead of neutron (string)
        :param builtins.str password: vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param builtins.str private_key_file: Private key content to use for SSH (string)
        :param builtins.str sec_groups: OpenStack comma separated security groups for the machine (string)
        :param builtins.str ssh_port: If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
        :param builtins.str ssh_user: If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
        :param builtins.str tenant_id: OpenStack tenant id. Conflicts with `tenant_name` (string)
        :param builtins.str tenant_name: OpenStack tenant name. Conflicts with `tenant_id` (string)
        :param builtins.str user_data_file: File containing an openstack userdata script (string)
        :param builtins.str username: vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `CloudCredential` from Rancher v2.2.x (string)
        :param builtins.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.
               
               > **Note for OpenStack users:**: `keypair_name` is required to be in the schema even if there are no references in rancher itself
        :param builtins.str volume_id: OpenStack volume id of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param builtins.str volume_name: OpenStack volume name of existing volume. Applicable only when `boot_from_volume` is `true` (string)
        :param builtins.str volume_size: OpenStack volume size (GiB). Required when `boot_from_volume` is `true` (string)
        :param builtins.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) -> builtins.str:
        """
        OpenStack authentication URL (string)
        """
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        """
        OpenStack availability zone (string)
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        """
        AWS region. Default `eu-west-2` (string)
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[builtins.str]:
        """
        OpenStack active timeout Default `200` (string)
        """
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[builtins.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[builtins.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[builtins.str]:
        """
        OpenStack application credential secret (string)
        """
        return pulumi.get(self, "application_credential_secret")

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[builtins.bool]:
        """
        Enable booting from volume. Default is `false` (bool)
        """
        return pulumi.get(self, "boot_from_volume")

    @property
    @pulumi.getter
    def cacert(self) -> Optional[builtins.str]:
        """
        CA certificate bundle to verify against (string)
        """
        return pulumi.get(self, "cacert")

    @property
    @pulumi.getter(name="configDrive")
    def config_drive(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.bool]:
        """
        Disable TLS credential checking. Default `false` (bool)
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.bool]:
        """
        Use the nova networking services instead of neutron (string)
        """
        return pulumi.get(self, "nova_network")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.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[builtins.str]:
        """
        File containing an openstack userdata script (string)
        """
        return pulumi.get(self, "user_data_file")

    @property
    @pulumi.getter
    def username(self) -> Optional[builtins.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[builtins.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.

        > **Note for OpenStack users:**: `keypair_name` is required to be in the schema even if there are no references in rancher itself
        """
        return pulumi.get(self, "volume_device_path")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.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 NodeTemplateOutscaleConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "extraTagsAlls":
            suggest = "extra_tags_alls"
        elif key == "extraTagsInstances":
            suggest = "extra_tags_instances"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "rootDiskIops":
            suggest = "root_disk_iops"
        elif key == "rootDiskSize":
            suggest = "root_disk_size"
        elif key == "rootDiskType":
            suggest = "root_disk_type"
        elif key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "sourceOmi":
            suggest = "source_omi"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateOutscaleConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateOutscaleConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateOutscaleConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: builtins.str,
                 secret_key: builtins.str,
                 extra_tags_alls: Optional[Sequence[builtins.str]] = None,
                 extra_tags_instances: Optional[Sequence[builtins.str]] = None,
                 instance_type: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 root_disk_iops: Optional[builtins.int] = None,
                 root_disk_size: Optional[builtins.int] = None,
                 root_disk_type: Optional[builtins.str] = None,
                 security_group_ids: Optional[Sequence[builtins.str]] = None,
                 source_omi: Optional[builtins.str] = None):
        """
        :param builtins.str access_key: Outscale Access Key
        :param builtins.str secret_key: Outscale Secret Key
        :param Sequence[builtins.str] extra_tags_alls: Extra tags for all created resources (e.g. key1=value1,key2=value2)
        :param Sequence[builtins.str] extra_tags_instances: Extra tags only for instances (e.g. key1=value1,key2=value2)
        :param builtins.str instance_type: Outscale VM type
        :param builtins.str region: Outscale Region
        :param builtins.int root_disk_iops: Iops for io1 Root Disk. From 1 to 13000.
        :param builtins.int root_disk_size: Size of the Root Disk (in GB). From 1 to 14901.
        :param builtins.str root_disk_type: Type of the Root Disk. Possible values are :'standard', 'gp2' or 'io1'.
        :param Sequence[builtins.str] security_group_ids: Ids of user defined Security Groups to add to the machine
        :param builtins.str source_omi: Outscale Machine Image to use as bootstrap for the VM
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if extra_tags_alls is not None:
            pulumi.set(__self__, "extra_tags_alls", extra_tags_alls)
        if extra_tags_instances is not None:
            pulumi.set(__self__, "extra_tags_instances", extra_tags_instances)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if root_disk_iops is not None:
            pulumi.set(__self__, "root_disk_iops", root_disk_iops)
        if root_disk_size is not None:
            pulumi.set(__self__, "root_disk_size", root_disk_size)
        if root_disk_type is not None:
            pulumi.set(__self__, "root_disk_type", root_disk_type)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if source_omi is not None:
            pulumi.set(__self__, "source_omi", source_omi)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> builtins.str:
        """
        Outscale Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> builtins.str:
        """
        Outscale Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="extraTagsAlls")
    def extra_tags_alls(self) -> Optional[Sequence[builtins.str]]:
        """
        Extra tags for all created resources (e.g. key1=value1,key2=value2)
        """
        return pulumi.get(self, "extra_tags_alls")

    @property
    @pulumi.getter(name="extraTagsInstances")
    def extra_tags_instances(self) -> Optional[Sequence[builtins.str]]:
        """
        Extra tags only for instances (e.g. key1=value1,key2=value2)
        """
        return pulumi.get(self, "extra_tags_instances")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        Outscale VM type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        Outscale Region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="rootDiskIops")
    def root_disk_iops(self) -> Optional[builtins.int]:
        """
        Iops for io1 Root Disk. From 1 to 13000.
        """
        return pulumi.get(self, "root_disk_iops")

    @property
    @pulumi.getter(name="rootDiskSize")
    def root_disk_size(self) -> Optional[builtins.int]:
        """
        Size of the Root Disk (in GB). From 1 to 14901.
        """
        return pulumi.get(self, "root_disk_size")

    @property
    @pulumi.getter(name="rootDiskType")
    def root_disk_type(self) -> Optional[builtins.str]:
        """
        Type of the Root Disk. Possible values are :'standard', 'gp2' or 'io1'.
        """
        return pulumi.get(self, "root_disk_type")

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[Sequence[builtins.str]]:
        """
        Ids of user defined Security Groups to add to the machine
        """
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="sourceOmi")
    def source_omi(self) -> Optional[builtins.str]:
        """
        Outscale Machine Image to use as bootstrap for the VM
        """
        return pulumi.get(self, "source_omi")


@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 == "gracefulShutdownTimeout":
            suggest = "graceful_shutdown_timeout"
        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[builtins.str] = None,
                 cfgparams: Optional[Sequence[builtins.str]] = None,
                 clone_from: Optional[builtins.str] = None,
                 cloud_config: Optional[builtins.str] = None,
                 cloudinit: Optional[builtins.str] = None,
                 content_library: Optional[builtins.str] = None,
                 cpu_count: Optional[builtins.str] = None,
                 creation_type: Optional[builtins.str] = None,
                 custom_attributes: Optional[Sequence[builtins.str]] = None,
                 datacenter: Optional[builtins.str] = None,
                 datastore: Optional[builtins.str] = None,
                 datastore_cluster: Optional[builtins.str] = None,
                 disk_size: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 graceful_shutdown_timeout: Optional[builtins.str] = None,
                 hostsystem: Optional[builtins.str] = None,
                 memory_size: Optional[builtins.str] = None,
                 networks: Optional[Sequence[builtins.str]] = None,
                 password: Optional[builtins.str] = None,
                 pool: Optional[builtins.str] = None,
                 ssh_password: Optional[builtins.str] = None,
                 ssh_port: Optional[builtins.str] = None,
                 ssh_user: Optional[builtins.str] = None,
                 ssh_user_group: Optional[builtins.str] = None,
                 tags: Optional[Sequence[builtins.str]] = None,
                 username: Optional[builtins.str] = None,
                 vapp_ip_allocation_policy: Optional[builtins.str] = None,
                 vapp_ip_protocol: Optional[builtins.str] = None,
                 vapp_properties: Optional[Sequence[builtins.str]] = None,
                 vapp_transport: Optional[builtins.str] = None,
                 vcenter: Optional[builtins.str] = None,
                 vcenter_port: Optional[builtins.str] = None):
        """
        :param builtins.str boot2docker_url: vSphere URL for boot2docker image
        :param Sequence[builtins.str] cfgparams: vSphere vm configuration parameters (used for guestinfo)
        :param builtins.str clone_from: If you choose creation type clone a name of what you want to clone is required
        :param builtins.str cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data
        :param builtins.str cloudinit: vSphere cloud-init filepath or url to add to guestinfo
        :param builtins.str content_library: If you choose to clone from a content library template specify the name of the library
        :param builtins.str cpu_count: vSphere CPU number for docker VM
        :param builtins.str creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        :param Sequence[builtins.str] custom_attributes: vSphere custom attributes, format key/value e.g. '200=my custom value'
        :param builtins.str datacenter: vSphere datacenter for virtual machine
        :param builtins.str datastore: vSphere datastore for virtual machine
        :param builtins.str datastore_cluster: vSphere datastore cluster for virtual machine
        :param builtins.str disk_size: vSphere size of disk for docker VM (in MB)
        :param builtins.str folder: vSphere folder for the docker VM. This folder must already exist in the datacenter
        :param builtins.str graceful_shutdown_timeout: Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        :param builtins.str hostsystem: vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS
        :param builtins.str memory_size: vSphere size of memory for docker VM (in MB)
        :param Sequence[builtins.str] networks: vSphere network where the virtual machine will be attached
        :param builtins.str password: vSphere password
        :param builtins.str pool: vSphere resource pool for docker VM
        :param builtins.str ssh_password: If using a non-B2D image you can specify the ssh password
        :param builtins.str ssh_port: If using a non-B2D image you can specify the ssh port
        :param builtins.str ssh_user: If using a non-B2D image you can specify the ssh user
        :param builtins.str ssh_user_group: If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        :param Sequence[builtins.str] tags: vSphere tags id e.g. urn:xxx
        :param builtins.str username: vSphere username
        :param builtins.str vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        :param builtins.str vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        :param Sequence[builtins.str] vapp_properties: vSphere vApp properties
        :param builtins.str vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        :param builtins.str vcenter: vSphere IP/hostname for vCenter
        :param builtins.str vcenter_port: vSphere Port for vCenter
        """
        if boot2docker_url is not None:
            pulumi.set(__self__, "boot2docker_url", boot2docker_url)
        if cfgparams is not None:
            pulumi.set(__self__, "cfgparams", cfgparams)
        if clone_from is not None:
            pulumi.set(__self__, "clone_from", clone_from)
        if cloud_config is not None:
            pulumi.set(__self__, "cloud_config", cloud_config)
        if cloudinit is not None:
            pulumi.set(__self__, "cloudinit", cloudinit)
        if content_library is not None:
            pulumi.set(__self__, "content_library", content_library)
        if cpu_count is not None:
            pulumi.set(__self__, "cpu_count", cpu_count)
        if creation_type is not None:
            pulumi.set(__self__, "creation_type", creation_type)
        if custom_attributes is not None:
            pulumi.set(__self__, "custom_attributes", custom_attributes)
        if datacenter is not None:
            pulumi.set(__self__, "datacenter", datacenter)
        if datastore is not None:
            pulumi.set(__self__, "datastore", datastore)
        if datastore_cluster is not None:
            pulumi.set(__self__, "datastore_cluster", datastore_cluster)
        if disk_size is not None:
            pulumi.set(__self__, "disk_size", disk_size)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)
        if hostsystem is not None:
            pulumi.set(__self__, "hostsystem", hostsystem)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if pool is not None:
            pulumi.set(__self__, "pool", pool)
        if ssh_password is not None:
            pulumi.set(__self__, "ssh_password", ssh_password)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if ssh_user_group is not None:
            pulumi.set(__self__, "ssh_user_group", ssh_user_group)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if vapp_ip_allocation_policy is not None:
            pulumi.set(__self__, "vapp_ip_allocation_policy", vapp_ip_allocation_policy)
        if vapp_ip_protocol is not None:
            pulumi.set(__self__, "vapp_ip_protocol", vapp_ip_protocol)
        if vapp_properties is not None:
            pulumi.set(__self__, "vapp_properties", vapp_properties)
        if vapp_transport is not None:
            pulumi.set(__self__, "vapp_transport", vapp_transport)
        if vcenter is not None:
            pulumi.set(__self__, "vcenter", vcenter)
        if vcenter_port is not None:
            pulumi.set(__self__, "vcenter_port", vcenter_port)

    @property
    @pulumi.getter(name="boot2dockerUrl")
    def boot2docker_url(self) -> Optional[builtins.str]:
        """
        vSphere URL for boot2docker image
        """
        return pulumi.get(self, "boot2docker_url")

    @property
    @pulumi.getter
    def cfgparams(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere vm configuration parameters (used for guestinfo)
        """
        return pulumi.get(self, "cfgparams")

    @property
    @pulumi.getter(name="cloneFrom")
    def clone_from(self) -> Optional[builtins.str]:
        """
        If you choose creation type clone a name of what you want to clone is required
        """
        return pulumi.get(self, "clone_from")

    @property
    @pulumi.getter(name="cloudConfig")
    def cloud_config(self) -> Optional[builtins.str]:
        """
        Filepath to a cloud-config yaml file to put into the ISO user-data
        """
        return pulumi.get(self, "cloud_config")

    @property
    @pulumi.getter
    def cloudinit(self) -> Optional[builtins.str]:
        """
        vSphere cloud-init filepath or url to add to guestinfo
        """
        return pulumi.get(self, "cloudinit")

    @property
    @pulumi.getter(name="contentLibrary")
    def content_library(self) -> Optional[builtins.str]:
        """
        If you choose to clone from a content library template specify the name of the library
        """
        return pulumi.get(self, "content_library")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[builtins.str]:
        """
        vSphere CPU number for docker VM
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="creationType")
    def creation_type(self) -> Optional[builtins.str]:
        """
        Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        """
        return pulumi.get(self, "creation_type")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere custom attributes, format key/value e.g. '200=my custom value'
        """
        return pulumi.get(self, "custom_attributes")

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[builtins.str]:
        """
        vSphere datacenter for virtual machine
        """
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def datastore(self) -> Optional[builtins.str]:
        """
        vSphere datastore for virtual machine
        """
        return pulumi.get(self, "datastore")

    @property
    @pulumi.getter(name="datastoreCluster")
    def datastore_cluster(self) -> Optional[builtins.str]:
        """
        vSphere datastore cluster for virtual machine
        """
        return pulumi.get(self, "datastore_cluster")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[builtins.str]:
        """
        vSphere size of disk for docker VM (in MB)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        """
        vSphere folder for the docker VM. This folder must already exist in the datacenter
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[builtins.str]:
        """
        Duration in seconds before the graceful shutdown of the VM times out and the VM is destroyed. A force destroy will be performed when the value is zero
        """
        return pulumi.get(self, "graceful_shutdown_timeout")

    @property
    @pulumi.getter
    def hostsystem(self) -> Optional[builtins.str]:
        """
        vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS
        """
        return pulumi.get(self, "hostsystem")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[builtins.str]:
        """
        vSphere size of memory for docker VM (in MB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter
    def networks(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere network where the virtual machine will be attached
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        """
        vSphere password
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def pool(self) -> Optional[builtins.str]:
        """
        vSphere resource pool for docker VM
        """
        return pulumi.get(self, "pool")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image you can specify the ssh password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image you can specify the ssh port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image you can specify the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="sshUserGroup")
    def ssh_user_group(self) -> Optional[builtins.str]:
        """
        If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        """
        return pulumi.get(self, "ssh_user_group")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere tags id e.g. urn:xxx
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def username(self) -> Optional[builtins.str]:
        """
        vSphere username
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vappIpAllocationPolicy")
    def vapp_ip_allocation_policy(self) -> Optional[builtins.str]:
        """
        vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        """
        return pulumi.get(self, "vapp_ip_allocation_policy")

    @property
    @pulumi.getter(name="vappIpProtocol")
    def vapp_ip_protocol(self) -> Optional[builtins.str]:
        """
        vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        """
        return pulumi.get(self, "vapp_ip_protocol")

    @property
    @pulumi.getter(name="vappProperties")
    def vapp_properties(self) -> Optional[Sequence[builtins.str]]:
        """
        vSphere vApp properties
        """
        return pulumi.get(self, "vapp_properties")

    @property
    @pulumi.getter(name="vappTransport")
    def vapp_transport(self) -> Optional[builtins.str]:
        """
        vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        """
        return pulumi.get(self, "vapp_transport")

    @property
    @pulumi.getter
    def vcenter(self) -> Optional[builtins.str]:
        """
        vSphere IP/hostname for vCenter
        """
        return pulumi.get(self, "vcenter")

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[builtins.str]:
        """
        vSphere Port for vCenter
        """
        return pulumi.get(self, "vcenter_port")


@pulumi.output_type
class PodSecurityAdmissionConfigurationTemplateDefaults(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "auditVersion":
            suggest = "audit_version"
        elif key == "enforceVersion":
            suggest = "enforce_version"
        elif key == "warnVersion":
            suggest = "warn_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityAdmissionConfigurationTemplateDefaults. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityAdmissionConfigurationTemplateDefaults.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityAdmissionConfigurationTemplateDefaults.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 audit: Optional[builtins.str] = None,
                 audit_version: Optional[builtins.str] = None,
                 enforce: Optional[builtins.str] = None,
                 enforce_version: Optional[builtins.str] = None,
                 warn: Optional[builtins.str] = None,
                 warn_version: Optional[builtins.str] = None):
        """
        :param builtins.str audit: Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param builtins.str audit_version: Pod Security Admission Configuration audit version (default: latest)
        :param builtins.str enforce: Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param builtins.str enforce_version: Pod Security Admission Configuration enforce version (default: latest)
        :param builtins.str warn: Pod Security Admission Configuration warn. This warns the user about a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param builtins.str warn_version: Pod Security Admission Configuration warn version (default: latest)
        """
        if audit is not None:
            pulumi.set(__self__, "audit", audit)
        if audit_version is not None:
            pulumi.set(__self__, "audit_version", audit_version)
        if enforce is not None:
            pulumi.set(__self__, "enforce", enforce)
        if enforce_version is not None:
            pulumi.set(__self__, "enforce_version", enforce_version)
        if warn is not None:
            pulumi.set(__self__, "warn", warn)
        if warn_version is not None:
            pulumi.set(__self__, "warn_version", warn_version)

    @property
    @pulumi.getter
    def audit(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "audit")

    @property
    @pulumi.getter(name="auditVersion")
    def audit_version(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration audit version (default: latest)
        """
        return pulumi.get(self, "audit_version")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter(name="enforceVersion")
    def enforce_version(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration enforce version (default: latest)
        """
        return pulumi.get(self, "enforce_version")

    @property
    @pulumi.getter
    def warn(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration warn. This warns the user about a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "warn")

    @property
    @pulumi.getter(name="warnVersion")
    def warn_version(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration warn version (default: latest)
        """
        return pulumi.get(self, "warn_version")


@pulumi.output_type
class PodSecurityAdmissionConfigurationTemplateExemptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "runtimeClasses":
            suggest = "runtime_classes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityAdmissionConfigurationTemplateExemptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityAdmissionConfigurationTemplateExemptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityAdmissionConfigurationTemplateExemptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 namespaces: Optional[Sequence[builtins.str]] = None,
                 runtime_classes: Optional[Sequence[builtins.str]] = None,
                 usernames: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] namespaces: Pod Security Admission Configuration namespace exemptions
        :param Sequence[builtins.str] runtime_classes: Pod Security Admission Configuration runtime class exemptions
        :param Sequence[builtins.str] usernames: Pod Security Admission Configuration username exemptions
        """
        if namespaces is not None:
            pulumi.set(__self__, "namespaces", namespaces)
        if runtime_classes is not None:
            pulumi.set(__self__, "runtime_classes", runtime_classes)
        if usernames is not None:
            pulumi.set(__self__, "usernames", usernames)

    @property
    @pulumi.getter
    def namespaces(self) -> Optional[Sequence[builtins.str]]:
        """
        Pod Security Admission Configuration namespace exemptions
        """
        return pulumi.get(self, "namespaces")

    @property
    @pulumi.getter(name="runtimeClasses")
    def runtime_classes(self) -> Optional[Sequence[builtins.str]]:
        """
        Pod Security Admission Configuration runtime class exemptions
        """
        return pulumi.get(self, "runtime_classes")

    @property
    @pulumi.getter
    def usernames(self) -> Optional[Sequence[builtins.str]]:
        """
        Pod Security Admission Configuration username exemptions
        """
        return pulumi.get(self, "usernames")


@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[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None):
        """
        :param builtins.str limits_cpu: Limit for limits cpu in project (string)
        :param builtins.str limits_memory: Limit for limits memory in project (string)
        :param builtins.str requests_cpu: Limit for requests cpu in project (string)
        :param builtins.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[builtins.str]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        """
        Limit for limits memory in project (string)
        """
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")


@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[builtins.str] = None,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 persistent_volume_claims: Optional[builtins.str] = None,
                 pods: Optional[builtins.str] = None,
                 replication_controllers: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None,
                 requests_storage: Optional[builtins.str] = None,
                 secrets: Optional[builtins.str] = None,
                 services: Optional[builtins.str] = None,
                 services_load_balancers: Optional[builtins.str] = None,
                 services_node_ports: Optional[builtins.str] = None):
        """
        :param builtins.str config_maps: Limit for config maps in project (string)
        :param builtins.str limits_cpu: Limit for limits cpu in project (string)
        :param builtins.str limits_memory: Limit for limits memory in project (string)
        :param builtins.str persistent_volume_claims: Limit for persistent volume claims in project (string)
        :param builtins.str pods: Limit for pods in project (string)
        :param builtins.str replication_controllers: Limit for replication controllers in project (string)
        :param builtins.str requests_cpu: Limit for requests cpu in project (string)
        :param builtins.str requests_memory: Limit for requests memory in project (string)
        :param builtins.str requests_storage: Limit for requests storage in project (string)
        :param builtins.str secrets: Limit for secrets in project (string)
        :param builtins.str services_load_balancers: Limit for services load balancers in project (string)
        :param builtins.str services_node_ports: Limit for services node ports in project (string)
               
               More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
        """
        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[builtins.str]:
        """
        Limit for config maps in project (string)
        """
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[builtins.str]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.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[builtins.str]:
        """
        Limit for persistent volume claims in project (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[builtins.str]:
        """
        Limit for pods in project (string)
        """
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[builtins.str]:
        """
        Limit for replication controllers in project (string)
        """
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[builtins.str]:
        """
        Limit for requests storage in project (string)
        """
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[builtins.str]:
        """
        Limit for secrets in project (string)
        """
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[builtins.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[builtins.str]:
        """
        Limit for services node ports in project (string)

        More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
        """
        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[builtins.str] = None,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 persistent_volume_claims: Optional[builtins.str] = None,
                 pods: Optional[builtins.str] = None,
                 replication_controllers: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None,
                 requests_storage: Optional[builtins.str] = None,
                 secrets: Optional[builtins.str] = None,
                 services: Optional[builtins.str] = None,
                 services_load_balancers: Optional[builtins.str] = None,
                 services_node_ports: Optional[builtins.str] = None):
        """
        :param builtins.str config_maps: Limit for config maps in project (string)
        :param builtins.str limits_cpu: Limit for limits cpu in project (string)
        :param builtins.str limits_memory: Limit for limits memory in project (string)
        :param builtins.str persistent_volume_claims: Limit for persistent volume claims in project (string)
        :param builtins.str pods: Limit for pods in project (string)
        :param builtins.str replication_controllers: Limit for replication controllers in project (string)
        :param builtins.str requests_cpu: Limit for requests cpu in project (string)
        :param builtins.str requests_memory: Limit for requests memory in project (string)
        :param builtins.str requests_storage: Limit for requests storage in project (string)
        :param builtins.str secrets: Limit for secrets in project (string)
        :param builtins.str services_load_balancers: Limit for services load balancers in project (string)
        :param builtins.str services_node_ports: Limit for services node ports in project (string)
               
               More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
        """
        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[builtins.str]:
        """
        Limit for config maps in project (string)
        """
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[builtins.str]:
        """
        Limit for limits cpu in project (string)
        """
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.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[builtins.str]:
        """
        Limit for persistent volume claims in project (string)
        """
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[builtins.str]:
        """
        Limit for pods in project (string)
        """
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[builtins.str]:
        """
        Limit for replication controllers in project (string)
        """
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        """
        Limit for requests cpu in project (string)
        """
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        """
        Limit for requests memory in project (string)
        """
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[builtins.str]:
        """
        Limit for requests storage in project (string)
        """
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[builtins.str]:
        """
        Limit for secrets in project (string)
        """
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[builtins.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[builtins.str]:
        """
        Limit for services node ports in project (string)

        More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
        """
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class RegistryRegistry(dict):
    def __init__(__self__, *,
                 address: builtins.str,
                 password: Optional[builtins.str] = None,
                 username: Optional[builtins.str] = None):
        """
        :param builtins.str address: Address for registry.
        :param builtins.str password: Password for the registry (string)
        :param builtins.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) -> builtins.str:
        """
        Address for registry.
        """
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        """
        Password for the registry (string)
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[builtins.str]:
        """
        Username for the registry (string)
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class RoleTemplateExternalRule(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 RoleTemplateExternalRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RoleTemplateExternalRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RoleTemplateExternalRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_groups: Optional[Sequence[builtins.str]] = None,
                 non_resource_urls: Optional[Sequence[builtins.str]] = None,
                 resource_names: Optional[Sequence[builtins.str]] = None,
                 resources: Optional[Sequence[builtins.str]] = None,
                 verbs: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] api_groups: Policy rule api groups
        :param Sequence[builtins.str] non_resource_urls: Policy rule non resource urls
        :param Sequence[builtins.str] resource_names: Policy rule resource names
        :param Sequence[builtins.str] resources: Policy rule resources
        :param Sequence[builtins.str] verbs: Policy rule verbs
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule verbs
        """
        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[builtins.str]] = None,
                 non_resource_urls: Optional[Sequence[builtins.str]] = None,
                 resource_names: Optional[Sequence[builtins.str]] = None,
                 resources: Optional[Sequence[builtins.str]] = None,
                 verbs: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] api_groups: Policy rule api groups
        :param Sequence[builtins.str] non_resource_urls: Policy rule non resource urls
        :param Sequence[builtins.str] resource_names: Policy rule resource names
        :param Sequence[builtins.str] resources: Policy rule resources
        :param Sequence[builtins.str] verbs: Policy rule verbs
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetClusterAksConfigResult(dict):
    def __init__(__self__, *,
                 agent_dns_prefix: builtins.str,
                 client_id: builtins.str,
                 client_secret: builtins.str,
                 kubernetes_version: builtins.str,
                 load_balancer_sku: builtins.str,
                 master_dns_prefix: builtins.str,
                 resource_group: builtins.str,
                 ssh_public_key_contents: builtins.str,
                 subnet: builtins.str,
                 subscription_id: builtins.str,
                 tag: Mapping[str, builtins.str],
                 tags: Sequence[builtins.str],
                 tenant_id: builtins.str,
                 virtual_network: builtins.str,
                 virtual_network_resource_group: builtins.str,
                 aad_server_app_secret: Optional[builtins.str] = None,
                 aad_tenant_id: Optional[builtins.str] = None,
                 add_client_app_id: Optional[builtins.str] = None,
                 add_server_app_id: Optional[builtins.str] = None,
                 admin_username: Optional[builtins.str] = None,
                 agent_os_disk_size: Optional[builtins.int] = None,
                 agent_pool_name: Optional[builtins.str] = None,
                 agent_storage_profile: Optional[builtins.str] = None,
                 agent_vm_size: Optional[builtins.str] = None,
                 auth_base_url: Optional[builtins.str] = None,
                 base_url: Optional[builtins.str] = None,
                 count: Optional[builtins.int] = None,
                 dns_service_ip: Optional[builtins.str] = None,
                 docker_bridge_cidr: Optional[builtins.str] = None,
                 enable_http_application_routing: Optional[builtins.bool] = None,
                 enable_monitoring: Optional[builtins.bool] = None,
                 location: Optional[builtins.str] = None,
                 log_analytics_workspace: Optional[builtins.str] = None,
                 log_analytics_workspace_resource_group: Optional[builtins.str] = None,
                 max_pods: Optional[builtins.int] = None,
                 network_plugin: Optional[builtins.str] = None,
                 network_policy: Optional[builtins.str] = None,
                 pod_cidr: Optional[builtins.str] = None,
                 service_cidr: Optional[builtins.str] = None):
        """
        :param builtins.str agent_dns_prefix: DNS prefix to be used to create the FQDN for the agent pool
        :param builtins.str client_id: Azure client ID to use
        :param builtins.str client_secret: Azure client secret associated with the "client id"
        :param builtins.str kubernetes_version: Specify the version of Kubernetes
        :param builtins.str load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        :param builtins.str master_dns_prefix: DNS prefix to use the Kubernetes cluster control pane
        :param builtins.str resource_group: The name of the Cluster resource group
        :param builtins.str ssh_public_key_contents: Contents of the SSH public key used to authenticate with Linux hosts
        :param builtins.str subnet: The name of an existing Azure Virtual Subnet. Composite of agent virtual network subnet ID
        :param builtins.str subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription
        :param Mapping[str, builtins.str] tag: Tags for Kubernetes cluster. For example, foo=bar
        :param Sequence[builtins.str] tags: Tags for Kubernetes cluster. For example, `["foo=bar","bar=foo"]`
        :param builtins.str tenant_id: Azure tenant ID to use
        :param builtins.str virtual_network: The name of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        :param builtins.str virtual_network_resource_group: The resource group of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        :param builtins.str aad_server_app_secret: The secret of an Azure Active Directory server application
        :param builtins.str aad_tenant_id: The ID of an Azure Active Directory tenant
        :param builtins.str add_client_app_id: The ID of an Azure Active Directory client application of type "Native". This application is for user login via kubectl
        :param builtins.str add_server_app_id: The ID of an Azure Active Directory server application of type "Web app/API". This application represents the managed cluster's apiserver (Server application)
        :param builtins.str admin_username: The administrator username to use for Linux hosts
        :param builtins.int agent_os_disk_size: GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the "agent vm size" specified
        :param builtins.str agent_pool_name: Name for the agent pool, upto 12 alphanumeric characters
        :param builtins.str agent_storage_profile: Storage profile specifies what kind of storage used on machine in the agent pool. Chooses from [ManagedDisks StorageAccount]
        :param builtins.str agent_vm_size: Size of machine in the agent pool
        :param builtins.str auth_base_url: Different authentication API url to use
        :param builtins.str base_url: Different resource management API url to use
        :param builtins.int count: Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive)
        :param builtins.str dns_service_ip: An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes Service address range specified in "service cidr"
        :param builtins.str docker_bridge_cidr: A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes Service address range specified in "service cidr"
        :param builtins.bool enable_http_application_routing: Enable the Kubernetes ingress with automatic public DNS name creation
        :param builtins.bool enable_monitoring: Turn on Azure Log Analytics monitoring. Uses the Log Analytics "Default" workspace if it exists, else creates one. if using an existing workspace, specifies "log analytics workspace resource id"
        :param builtins.str location: Azure Kubernetes cluster location
        :param builtins.str log_analytics_workspace: The name of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses '{resource group}-{subscription id}-{location code}'
        :param builtins.str log_analytics_workspace_resource_group: The resource group of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses the 'Cluster' resource group
        :param builtins.int max_pods: Maximum number of pods that can run on a node
        :param builtins.str network_plugin: Network plugin used for building Kubernetes network. Chooses from [azure kubenet]
        :param builtins.str network_policy: Network policy used for building Kubernetes network. Chooses from [calico]
        :param builtins.str pod_cidr: A CIDR notation IP range from which to assign Kubernetes Pod IPs when "network plugin" is specified in "kubenet".
        :param builtins.str service_cidr: A CIDR notation IP range from which to assign Kubernetes Service cluster IPs. It must not overlap with any Subnet IP ranges
        """
        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) -> builtins.str:
        """
        DNS prefix to be used to create the FQDN for the agent pool
        """
        return pulumi.get(self, "agent_dns_prefix")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> builtins.str:
        """
        Azure client ID to use
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> builtins.str:
        """
        Azure client secret associated with the "client id"
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        Specify the version of Kubernetes
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> builtins.str:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        return pulumi.get(self, "load_balancer_sku")

    @property
    @pulumi.getter(name="masterDnsPrefix")
    def master_dns_prefix(self) -> builtins.str:
        """
        DNS prefix to use the Kubernetes cluster control pane
        """
        return pulumi.get(self, "master_dns_prefix")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> builtins.str:
        """
        The name of the Cluster resource group
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="sshPublicKeyContents")
    def ssh_public_key_contents(self) -> builtins.str:
        """
        Contents of the SSH public key used to authenticate with Linux hosts
        """
        return pulumi.get(self, "ssh_public_key_contents")

    @property
    @pulumi.getter
    def subnet(self) -> builtins.str:
        """
        The name of an existing Azure Virtual Subnet. Composite of agent virtual network subnet ID
        """
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> builtins.str:
        """
        Subscription credentials which uniquely identify Microsoft Azure subscription
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    @_utilities.deprecated("""Use tags argument instead as []string""")
    def tag(self) -> Mapping[str, builtins.str]:
        """
        Tags for Kubernetes cluster. For example, foo=bar
        """
        return pulumi.get(self, "tag")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[builtins.str]:
        """
        Tags for Kubernetes cluster. For example, `["foo=bar","bar=foo"]`
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> builtins.str:
        """
        Azure tenant ID to use
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> builtins.str:
        """
        The name of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        """
        return pulumi.get(self, "virtual_network")

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> builtins.str:
        """
        The resource group of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        """
        return pulumi.get(self, "virtual_network_resource_group")

    @property
    @pulumi.getter(name="aadServerAppSecret")
    def aad_server_app_secret(self) -> Optional[builtins.str]:
        """
        The secret of an Azure Active Directory server application
        """
        return pulumi.get(self, "aad_server_app_secret")

    @property
    @pulumi.getter(name="aadTenantId")
    def aad_tenant_id(self) -> Optional[builtins.str]:
        """
        The ID of an Azure Active Directory tenant
        """
        return pulumi.get(self, "aad_tenant_id")

    @property
    @pulumi.getter(name="addClientAppId")
    def add_client_app_id(self) -> Optional[builtins.str]:
        """
        The ID of an Azure Active Directory client application of type "Native". This application is for user login via kubectl
        """
        return pulumi.get(self, "add_client_app_id")

    @property
    @pulumi.getter(name="addServerAppId")
    def add_server_app_id(self) -> Optional[builtins.str]:
        """
        The ID of an Azure Active Directory server application of type "Web app/API". This application represents the managed cluster's apiserver (Server application)
        """
        return pulumi.get(self, "add_server_app_id")

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> Optional[builtins.str]:
        """
        The administrator username to use for Linux hosts
        """
        return pulumi.get(self, "admin_username")

    @property
    @pulumi.getter(name="agentOsDiskSize")
    def agent_os_disk_size(self) -> Optional[builtins.int]:
        """
        GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the "agent vm size" specified
        """
        return pulumi.get(self, "agent_os_disk_size")

    @property
    @pulumi.getter(name="agentPoolName")
    def agent_pool_name(self) -> Optional[builtins.str]:
        """
        Name for the agent pool, upto 12 alphanumeric characters
        """
        return pulumi.get(self, "agent_pool_name")

    @property
    @pulumi.getter(name="agentStorageProfile")
    def agent_storage_profile(self) -> Optional[builtins.str]:
        """
        Storage profile specifies what kind of storage used on machine in the agent pool. Chooses from [ManagedDisks StorageAccount]
        """
        return pulumi.get(self, "agent_storage_profile")

    @property
    @pulumi.getter(name="agentVmSize")
    def agent_vm_size(self) -> Optional[builtins.str]:
        """
        Size of machine in the agent pool
        """
        return pulumi.get(self, "agent_vm_size")

    @property
    @pulumi.getter(name="authBaseUrl")
    def auth_base_url(self) -> Optional[builtins.str]:
        """
        Different authentication API url to use
        """
        return pulumi.get(self, "auth_base_url")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[builtins.str]:
        """
        Different resource management API url to use
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter
    def count(self) -> Optional[builtins.int]:
        """
        Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive)
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="dnsServiceIp")
    def dns_service_ip(self) -> Optional[builtins.str]:
        """
        An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes Service address range specified in "service cidr"
        """
        return pulumi.get(self, "dns_service_ip")

    @property
    @pulumi.getter(name="dockerBridgeCidr")
    def docker_bridge_cidr(self) -> Optional[builtins.str]:
        """
        A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes Service address range specified in "service cidr"
        """
        return pulumi.get(self, "docker_bridge_cidr")

    @property
    @pulumi.getter(name="enableHttpApplicationRouting")
    def enable_http_application_routing(self) -> Optional[builtins.bool]:
        """
        Enable the Kubernetes ingress with automatic public DNS name creation
        """
        return pulumi.get(self, "enable_http_application_routing")

    @property
    @pulumi.getter(name="enableMonitoring")
    def enable_monitoring(self) -> Optional[builtins.bool]:
        """
        Turn on Azure Log Analytics monitoring. Uses the Log Analytics "Default" workspace if it exists, else creates one. if using an existing workspace, specifies "log analytics workspace resource id"
        """
        return pulumi.get(self, "enable_monitoring")

    @property
    @pulumi.getter
    def location(self) -> Optional[builtins.str]:
        """
        Azure Kubernetes cluster location
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="logAnalyticsWorkspace")
    def log_analytics_workspace(self) -> Optional[builtins.str]:
        """
        The name of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses '{resource group}-{subscription id}-{location code}'
        """
        return pulumi.get(self, "log_analytics_workspace")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceResourceGroup")
    def log_analytics_workspace_resource_group(self) -> Optional[builtins.str]:
        """
        The resource group of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses the 'Cluster' resource group
        """
        return pulumi.get(self, "log_analytics_workspace_resource_group")

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[builtins.int]:
        """
        Maximum number of pods that can run on a node
        """
        return pulumi.get(self, "max_pods")

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> Optional[builtins.str]:
        """
        Network plugin used for building Kubernetes network. Chooses from [azure kubenet]
        """
        return pulumi.get(self, "network_plugin")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> Optional[builtins.str]:
        """
        Network policy used for building Kubernetes network. Chooses from [calico]
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[builtins.str]:
        """
        A CIDR notation IP range from which to assign Kubernetes Pod IPs when "network plugin" is specified in "kubenet".
        """
        return pulumi.get(self, "pod_cidr")

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[builtins.str]:
        """
        A CIDR notation IP range from which to assign Kubernetes Service cluster IPs. It must not overlap with any Subnet IP ranges
        """
        return pulumi.get(self, "service_cidr")


@pulumi.output_type
class GetClusterAksConfigV2Result(dict):
    def __init__(__self__, *,
                 cloud_credential_id: builtins.str,
                 http_application_routing: builtins.bool,
                 linux_admin_username: builtins.str,
                 linux_ssh_public_key: builtins.str,
                 load_balancer_sku: builtins.str,
                 log_analytics_workspace_group: builtins.str,
                 log_analytics_workspace_name: builtins.str,
                 monitoring: builtins.bool,
                 name: builtins.str,
                 network_dns_service_ip: builtins.str,
                 network_docker_bridge_cidr: builtins.str,
                 network_pod_cidr: builtins.str,
                 network_policy: builtins.str,
                 network_service_cidr: builtins.str,
                 node_resource_group: builtins.str,
                 private_cluster: builtins.bool,
                 resource_group: builtins.str,
                 resource_location: builtins.str,
                 subnet: builtins.str,
                 tags: Mapping[str, builtins.str],
                 virtual_network: builtins.str,
                 virtual_network_resource_group: builtins.str,
                 auth_base_url: Optional[builtins.str] = None,
                 authorized_ip_ranges: Optional[Sequence[builtins.str]] = None,
                 base_url: Optional[builtins.str] = None,
                 dns_prefix: Optional[builtins.str] = None,
                 imported: Optional[builtins.bool] = None,
                 kubernetes_version: Optional[builtins.str] = None,
                 network_plugin: Optional[builtins.str] = None,
                 node_pools: Optional[Sequence['outputs.GetClusterAksConfigV2NodePoolResult']] = None,
                 outbound_type: Optional[builtins.str] = None):
        """
        :param builtins.str cloud_credential_id: The AKS Cloud Credential ID to use
        :param builtins.bool http_application_routing: Enable AKS http application routing?
        :param builtins.str linux_admin_username: The AKS linux admin username
        :param builtins.str linux_ssh_public_key: The AKS linux ssh public key
        :param builtins.str load_balancer_sku: The AKS load balancer sku
        :param builtins.str log_analytics_workspace_group: The AKS log analytics workspace group
        :param builtins.str log_analytics_workspace_name: The AKS log analytics workspace name
        :param builtins.bool monitoring: Is AKS cluster monitoring enabled?
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str network_dns_service_ip: The AKS network dns service ip
        :param builtins.str network_docker_bridge_cidr: The AKS network docker bridge cidr
        :param builtins.str network_pod_cidr: The AKS network pod cidr
        :param builtins.str network_policy: The AKS network policy
        :param builtins.str network_service_cidr: The AKS network service cidr
        :param builtins.str node_resource_group: The AKS node resource group name
        :param builtins.bool private_cluster: Is AKS cluster private?
        :param builtins.str resource_group: The AKS resource group
        :param builtins.str resource_location: The AKS resource location
        :param builtins.str subnet: The AKS subnet
        :param Mapping[str, builtins.str] tags: The AKS cluster tags
        :param builtins.str virtual_network: The AKS virtual network
        :param builtins.str virtual_network_resource_group: The AKS virtual network resource group
        :param builtins.str auth_base_url: The AKS auth base url
        :param Sequence[builtins.str] authorized_ip_ranges: The AKS authorized ip ranges
        :param builtins.str base_url: The AKS base url
        :param builtins.str dns_prefix: The AKS dns prefix. Required if `import=false`
        :param builtins.bool imported: Is AKS cluster imported?
        :param builtins.str kubernetes_version: The kubernetes master version. Required if `import=false`
        :param builtins.str network_plugin: The AKS network plugin. Required if `import=false`
        :param Sequence['GetClusterAksConfigV2NodePoolArgs'] node_pools: The AKS node pools to use. Required if `import=false`
        :param builtins.str outbound_type: The AKS outbound type for the egress traffic
        """
        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__, "node_resource_group", node_resource_group)
        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)
        if outbound_type is not None:
            pulumi.set(__self__, "outbound_type", outbound_type)

    @property
    @pulumi.getter(name="cloudCredentialId")
    def cloud_credential_id(self) -> builtins.str:
        """
        The AKS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

    @property
    @pulumi.getter(name="httpApplicationRouting")
    def http_application_routing(self) -> builtins.bool:
        """
        Enable AKS http application routing?
        """
        return pulumi.get(self, "http_application_routing")

    @property
    @pulumi.getter(name="linuxAdminUsername")
    def linux_admin_username(self) -> builtins.str:
        """
        The AKS linux admin username
        """
        return pulumi.get(self, "linux_admin_username")

    @property
    @pulumi.getter(name="linuxSshPublicKey")
    def linux_ssh_public_key(self) -> builtins.str:
        """
        The AKS linux ssh public key
        """
        return pulumi.get(self, "linux_ssh_public_key")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> builtins.str:
        """
        The AKS load balancer sku
        """
        return pulumi.get(self, "load_balancer_sku")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceGroup")
    def log_analytics_workspace_group(self) -> builtins.str:
        """
        The AKS log analytics workspace group
        """
        return pulumi.get(self, "log_analytics_workspace_group")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceName")
    def log_analytics_workspace_name(self) -> builtins.str:
        """
        The AKS log analytics workspace name
        """
        return pulumi.get(self, "log_analytics_workspace_name")

    @property
    @pulumi.getter
    def monitoring(self) -> builtins.bool:
        """
        Is AKS cluster monitoring enabled?
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="networkDnsServiceIp")
    def network_dns_service_ip(self) -> builtins.str:
        """
        The AKS network dns service ip
        """
        return pulumi.get(self, "network_dns_service_ip")

    @property
    @pulumi.getter(name="networkDockerBridgeCidr")
    def network_docker_bridge_cidr(self) -> builtins.str:
        """
        The AKS network docker bridge cidr
        """
        return pulumi.get(self, "network_docker_bridge_cidr")

    @property
    @pulumi.getter(name="networkPodCidr")
    def network_pod_cidr(self) -> builtins.str:
        """
        The AKS network pod cidr
        """
        return pulumi.get(self, "network_pod_cidr")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> builtins.str:
        """
        The AKS network policy
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="networkServiceCidr")
    def network_service_cidr(self) -> builtins.str:
        """
        The AKS network service cidr
        """
        return pulumi.get(self, "network_service_cidr")

    @property
    @pulumi.getter(name="nodeResourceGroup")
    def node_resource_group(self) -> builtins.str:
        """
        The AKS node resource group name
        """
        return pulumi.get(self, "node_resource_group")

    @property
    @pulumi.getter(name="privateCluster")
    def private_cluster(self) -> builtins.bool:
        """
        Is AKS cluster private?
        """
        return pulumi.get(self, "private_cluster")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> builtins.str:
        """
        The AKS resource group
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="resourceLocation")
    def resource_location(self) -> builtins.str:
        """
        The AKS resource location
        """
        return pulumi.get(self, "resource_location")

    @property
    @pulumi.getter
    def subnet(self) -> builtins.str:
        """
        The AKS subnet
        """
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, builtins.str]:
        """
        The AKS cluster tags
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> builtins.str:
        """
        The AKS virtual network
        """
        return pulumi.get(self, "virtual_network")

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> builtins.str:
        """
        The AKS virtual network resource group
        """
        return pulumi.get(self, "virtual_network_resource_group")

    @property
    @pulumi.getter(name="authBaseUrl")
    def auth_base_url(self) -> Optional[builtins.str]:
        """
        The AKS auth base url
        """
        return pulumi.get(self, "auth_base_url")

    @property
    @pulumi.getter(name="authorizedIpRanges")
    def authorized_ip_ranges(self) -> Optional[Sequence[builtins.str]]:
        """
        The AKS authorized ip ranges
        """
        return pulumi.get(self, "authorized_ip_ranges")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[builtins.str]:
        """
        The AKS base url
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="dnsPrefix")
    def dns_prefix(self) -> Optional[builtins.str]:
        """
        The AKS dns prefix. Required if `import=false`
        """
        return pulumi.get(self, "dns_prefix")

    @property
    @pulumi.getter
    def imported(self) -> Optional[builtins.bool]:
        """
        Is AKS cluster imported?
        """
        return pulumi.get(self, "imported")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[builtins.str]:
        """
        The kubernetes master version. Required if `import=false`
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="networkPlugin")
    def network_plugin(self) -> Optional[builtins.str]:
        """
        The AKS network plugin. Required if `import=false`
        """
        return pulumi.get(self, "network_plugin")

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Optional[Sequence['outputs.GetClusterAksConfigV2NodePoolResult']]:
        """
        The AKS node pools to use. Required if `import=false`
        """
        return pulumi.get(self, "node_pools")

    @property
    @pulumi.getter(name="outboundType")
    def outbound_type(self) -> Optional[builtins.str]:
        """
        The AKS outbound type for the egress traffic
        """
        return pulumi.get(self, "outbound_type")


@pulumi.output_type
class GetClusterAksConfigV2NodePoolResult(dict):
    def __init__(__self__, *,
                 labels: Mapping[str, builtins.str],
                 name: builtins.str,
                 taints: Sequence[builtins.str],
                 vm_size: builtins.str,
                 availability_zones: Optional[Sequence[builtins.str]] = None,
                 count: Optional[builtins.int] = None,
                 enable_auto_scaling: Optional[builtins.bool] = None,
                 max_count: Optional[builtins.int] = None,
                 max_pods: Optional[builtins.int] = None,
                 max_surge: Optional[builtins.str] = None,
                 min_count: Optional[builtins.int] = None,
                 mode: Optional[builtins.str] = None,
                 orchestrator_version: Optional[builtins.str] = None,
                 os_disk_size_gb: Optional[builtins.int] = None,
                 os_disk_type: Optional[builtins.str] = None,
                 os_type: Optional[builtins.str] = None):
        """
        :param Mapping[str, builtins.str] labels: (Computed) Labels for Node Pool object (map)
        :param builtins.str name: The name of the Cluster (string)
        :param Sequence[builtins.str] taints: The AKS node pool taints
        :param builtins.str vm_size: The AKS node pool vm size
        :param Sequence[builtins.str] availability_zones: The AKS node pool availability zones
        :param builtins.int count: The AKS node pool count
        :param builtins.bool enable_auto_scaling: Is AKS node pool auto scaling enabled?
        :param builtins.int max_count: The AKS node pool max count
        :param builtins.int max_pods: The AKS node pool max pods
        :param builtins.str max_surge: The AKS node pool max surge
        :param builtins.int min_count: The AKS node pool min count
        :param builtins.str mode: The AKS node pool mode
        :param builtins.str orchestrator_version: The AKS node pool orchestrator version
        :param builtins.int os_disk_size_gb: The AKS node pool os disk size gb
        :param builtins.str os_disk_type: The AKS node pool os disk type
        :param builtins.str os_type: Enable AKS node pool os type
        """
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "taints", taints)
        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 max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if orchestrator_version is not None:
            pulumi.set(__self__, "orchestrator_version", orchestrator_version)
        if os_disk_size_gb is not None:
            pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
        if os_disk_type is not None:
            pulumi.set(__self__, "os_disk_type", os_disk_type)
        if os_type is not None:
            pulumi.set(__self__, "os_type", os_type)

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def taints(self) -> Sequence[builtins.str]:
        """
        The AKS node pool taints
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> builtins.str:
        """
        The AKS node pool vm size
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> Optional[Sequence[builtins.str]]:
        """
        The AKS node pool availability zones
        """
        return pulumi.get(self, "availability_zones")

    @property
    @pulumi.getter
    def count(self) -> Optional[builtins.int]:
        """
        The AKS node pool count
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="enableAutoScaling")
    def enable_auto_scaling(self) -> Optional[builtins.bool]:
        """
        Is AKS node pool auto scaling enabled?
        """
        return pulumi.get(self, "enable_auto_scaling")

    @property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> Optional[builtins.int]:
        """
        The AKS node pool max count
        """
        return pulumi.get(self, "max_count")

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[builtins.int]:
        """
        The AKS node pool max pods
        """
        return pulumi.get(self, "max_pods")

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.str]:
        """
        The AKS node pool max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> Optional[builtins.int]:
        """
        The AKS node pool min count
        """
        return pulumi.get(self, "min_count")

    @property
    @pulumi.getter
    def mode(self) -> Optional[builtins.str]:
        """
        The AKS node pool mode
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter(name="orchestratorVersion")
    def orchestrator_version(self) -> Optional[builtins.str]:
        """
        The AKS node pool orchestrator version
        """
        return pulumi.get(self, "orchestrator_version")

    @property
    @pulumi.getter(name="osDiskSizeGb")
    def os_disk_size_gb(self) -> Optional[builtins.int]:
        """
        The AKS node pool os disk size gb
        """
        return pulumi.get(self, "os_disk_size_gb")

    @property
    @pulumi.getter(name="osDiskType")
    def os_disk_type(self) -> Optional[builtins.str]:
        """
        The AKS node pool os disk type
        """
        return pulumi.get(self, "os_disk_type")

    @property
    @pulumi.getter(name="osType")
    def os_type(self) -> Optional[builtins.str]:
        """
        Enable AKS node pool os type
        """
        return pulumi.get(self, "os_type")


@pulumi.output_type
class GetClusterClusterAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[builtins.str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterClusterRegistrationTokenResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, builtins.str],
                 cluster_id: builtins.str,
                 command: builtins.str,
                 id: builtins.str,
                 insecure_command: builtins.str,
                 insecure_node_command: builtins.str,
                 insecure_windows_node_command: builtins.str,
                 labels: Mapping[str, builtins.str],
                 manifest_url: builtins.str,
                 name: builtins.str,
                 node_command: builtins.str,
                 token: builtins.str,
                 windows_node_command: builtins.str):
        """
        :param Mapping[str, builtins.str] annotations: (Computed) Annotations for Node Pool object (map)
        :param builtins.str id: (Computed) The ID of the resource (string)
        :param Mapping[str, builtins.str] labels: (Computed) Labels for Node Pool object (map)
        :param builtins.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, builtins.str]:
        """
        (Computed) Annotations for Node Pool object (map)
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> builtins.str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> builtins.str:
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> builtins.str:
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter(name="insecureNodeCommand")
    def insecure_node_command(self) -> builtins.str:
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> builtins.str:
        return pulumi.get(self, "insecure_windows_node_command")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> builtins.str:
        return pulumi.get(self, "manifest_url")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> builtins.str:
        return pulumi.get(self, "node_command")

    @property
    @pulumi.getter
    def token(self) -> builtins.str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> builtins.str:
        return pulumi.get(self, "windows_node_command")


@pulumi.output_type
class GetClusterClusterTemplateAnswersResult(dict):
    def __init__(__self__, *,
                 cluster_id: builtins.str,
                 project_id: builtins.str,
                 values: Mapping[str, builtins.str]):
        """
        :param builtins.str cluster_id: Cluster ID for answer
        :param builtins.str project_id: Project ID for answer
        :param Mapping[str, builtins.str] values: Key/values for answer
        """
        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) -> builtins.str:
        """
        Cluster ID for answer
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        Project ID for answer
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def values(self) -> Mapping[str, builtins.str]:
        """
        Key/values for answer
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetClusterClusterTemplateQuestionResult(dict):
    def __init__(__self__, *,
                 default: builtins.str,
                 variable: builtins.str,
                 required: Optional[builtins.bool] = None,
                 type: Optional[builtins.str] = None):
        """
        :param builtins.str default: Default variable value
        :param builtins.str variable: Variable name
        :param builtins.bool required: Required variable
        :param builtins.str type: Variable type
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "variable", variable)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def default(self) -> builtins.str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> builtins.str:
        """
        Variable name
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[builtins.bool]:
        """
        Required variable
        """
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        Variable type
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetClusterEksConfigResult(dict):
    def __init__(__self__, *,
                 access_key: builtins.str,
                 kubernetes_version: builtins.str,
                 secret_key: builtins.str,
                 user_data: builtins.str,
                 ami: Optional[builtins.str] = None,
                 associate_worker_node_public_ip: Optional[builtins.bool] = None,
                 desired_nodes: Optional[builtins.int] = None,
                 ebs_encryption: Optional[builtins.bool] = None,
                 instance_type: Optional[builtins.str] = None,
                 key_pair_name: Optional[builtins.str] = None,
                 maximum_nodes: Optional[builtins.int] = None,
                 minimum_nodes: Optional[builtins.int] = None,
                 node_volume_size: Optional[builtins.int] = None,
                 region: Optional[builtins.str] = None,
                 security_groups: Optional[Sequence[builtins.str]] = None,
                 service_role: Optional[builtins.str] = None,
                 session_token: Optional[builtins.str] = None,
                 subnets: Optional[Sequence[builtins.str]] = None,
                 virtual_network: Optional[builtins.str] = None):
        """
        :param builtins.str access_key: The AWS Client ID to use
        :param builtins.str kubernetes_version: The kubernetes master version
        :param builtins.str secret_key: The AWS Client Secret associated with the Client ID
        :param builtins.str user_data: Pass user-data to the nodes to perform automated configuration tasks
        :param builtins.str ami: A custom AMI ID to use for the worker nodes instead of the default
        :param builtins.bool associate_worker_node_public_ip: Associate public ip EKS worker nodes
        :param builtins.int desired_nodes: The desired number of worker nodes
        :param builtins.bool ebs_encryption: Enables EBS encryption of worker nodes
        :param builtins.str instance_type: The type of machine to use for worker nodes
        :param builtins.str key_pair_name: Allow user to specify key name to use
        :param builtins.int maximum_nodes: The maximum number of worker nodes
        :param builtins.int minimum_nodes: The minimum number of worker nodes
        :param builtins.int node_volume_size: The volume size for each node
        :param builtins.str region: The AWS Region to create the EKS cluster in
        :param Sequence[builtins.str] security_groups: List of security groups to use for the cluster
        :param builtins.str service_role: The service role to use to perform the cluster operations in AWS
        :param builtins.str session_token: A session token to use with the client key and secret if applicable
        :param Sequence[builtins.str] subnets: List of subnets in the virtual network to use
        :param builtins.str virtual_network: The name of the virtual network to use
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "secret_key", secret_key)
        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) -> builtins.str:
        """
        The AWS Client ID to use
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> builtins.str:
        """
        The AWS Client Secret associated with the Client ID
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> builtins.str:
        """
        Pass user-data to the nodes to perform automated configuration tasks
        """
        return pulumi.get(self, "user_data")

    @property
    @pulumi.getter
    def ami(self) -> Optional[builtins.str]:
        """
        A custom AMI ID to use for the worker nodes instead of the default
        """
        return pulumi.get(self, "ami")

    @property
    @pulumi.getter(name="associateWorkerNodePublicIp")
    def associate_worker_node_public_ip(self) -> Optional[builtins.bool]:
        """
        Associate public ip EKS worker nodes
        """
        return pulumi.get(self, "associate_worker_node_public_ip")

    @property
    @pulumi.getter(name="desiredNodes")
    def desired_nodes(self) -> Optional[builtins.int]:
        """
        The desired number of worker nodes
        """
        return pulumi.get(self, "desired_nodes")

    @property
    @pulumi.getter(name="ebsEncryption")
    def ebs_encryption(self) -> Optional[builtins.bool]:
        """
        Enables EBS encryption of worker nodes
        """
        return pulumi.get(self, "ebs_encryption")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        The type of machine to use for worker nodes
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="keyPairName")
    def key_pair_name(self) -> Optional[builtins.str]:
        """
        Allow user to specify key name to use
        """
        return pulumi.get(self, "key_pair_name")

    @property
    @pulumi.getter(name="maximumNodes")
    def maximum_nodes(self) -> Optional[builtins.int]:
        """
        The maximum number of worker nodes
        """
        return pulumi.get(self, "maximum_nodes")

    @property
    @pulumi.getter(name="minimumNodes")
    def minimum_nodes(self) -> Optional[builtins.int]:
        """
        The minimum number of worker nodes
        """
        return pulumi.get(self, "minimum_nodes")

    @property
    @pulumi.getter(name="nodeVolumeSize")
    def node_volume_size(self) -> Optional[builtins.int]:
        """
        The volume size for each node
        """
        return pulumi.get(self, "node_volume_size")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        The AWS Region to create the EKS cluster in
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        List of security groups to use for the cluster
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="serviceRole")
    def service_role(self) -> Optional[builtins.str]:
        """
        The service role to use to perform the cluster operations in AWS
        """
        return pulumi.get(self, "service_role")

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[builtins.str]:
        """
        A session token to use with the client key and secret if applicable
        """
        return pulumi.get(self, "session_token")

    @property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence[builtins.str]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> Optional[builtins.str]:
        """
        The name of the virtual network to use
        """
        return pulumi.get(self, "virtual_network")


@pulumi.output_type
class GetClusterEksConfigV2Result(dict):
    def __init__(__self__, *,
                 cloud_credential_id: builtins.str,
                 kubernetes_version: builtins.str,
                 name: builtins.str,
                 node_groups: Sequence['outputs.GetClusterEksConfigV2NodeGroupResult'],
                 private_access: builtins.bool,
                 public_access: builtins.bool,
                 public_access_sources: Sequence[builtins.str],
                 secrets_encryption: builtins.bool,
                 imported: Optional[builtins.bool] = None,
                 kms_key: Optional[builtins.str] = None,
                 logging_types: Optional[Sequence[builtins.str]] = None,
                 region: Optional[builtins.str] = None,
                 security_groups: Optional[Sequence[builtins.str]] = None,
                 service_role: Optional[builtins.str] = None,
                 subnets: Optional[Sequence[builtins.str]] = None,
                 tags: Optional[Mapping[str, builtins.str]] = None):
        """
        :param builtins.str cloud_credential_id: The AWS Cloud Credential ID to use
        :param builtins.str kubernetes_version: The kubernetes master version
        :param builtins.str name: The name of the Cluster (string)
        :param Sequence['GetClusterEksConfigV2NodeGroupArgs'] node_groups: The AWS node groups to use
        :param builtins.bool private_access: The EKS cluster has private access
        :param builtins.bool public_access: The EKS cluster has public access
        :param Sequence[builtins.str] public_access_sources: The EKS cluster public access sources
        :param builtins.bool secrets_encryption: Enable EKS cluster secret encryption
        :param builtins.bool imported: Is EKS cluster imported?
        :param builtins.str kms_key: The AWS kms key to use
        :param Sequence[builtins.str] logging_types: The AWS logging types
        :param builtins.str region: The AWS Region to create the EKS cluster in
        :param Sequence[builtins.str] security_groups: List of security groups to use for the cluster
        :param builtins.str service_role: The AWS service role to use
        :param Sequence[builtins.str] subnets: List of subnets in the virtual network to use
        :param Mapping[str, builtins.str] tags: The EKS cluster tags
        """
        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) -> builtins.str:
        """
        The AWS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeGroups")
    def node_groups(self) -> Sequence['outputs.GetClusterEksConfigV2NodeGroupResult']:
        """
        The AWS node groups to use
        """
        return pulumi.get(self, "node_groups")

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> builtins.bool:
        """
        The EKS cluster has private access
        """
        return pulumi.get(self, "private_access")

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> builtins.bool:
        """
        The EKS cluster has public access
        """
        return pulumi.get(self, "public_access")

    @property
    @pulumi.getter(name="publicAccessSources")
    def public_access_sources(self) -> Sequence[builtins.str]:
        """
        The EKS cluster public access sources
        """
        return pulumi.get(self, "public_access_sources")

    @property
    @pulumi.getter(name="secretsEncryption")
    def secrets_encryption(self) -> builtins.bool:
        """
        Enable EKS cluster secret encryption
        """
        return pulumi.get(self, "secrets_encryption")

    @property
    @pulumi.getter
    def imported(self) -> Optional[builtins.bool]:
        """
        Is EKS cluster imported?
        """
        return pulumi.get(self, "imported")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[builtins.str]:
        """
        The AWS kms key to use
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter(name="loggingTypes")
    def logging_types(self) -> Optional[Sequence[builtins.str]]:
        """
        The AWS logging types
        """
        return pulumi.get(self, "logging_types")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        The AWS Region to create the EKS cluster in
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        List of security groups to use for the cluster
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="serviceRole")
    def service_role(self) -> Optional[builtins.str]:
        """
        The AWS service role to use
        """
        return pulumi.get(self, "service_role")

    @property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence[builtins.str]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, builtins.str]]:
        """
        The EKS cluster tags
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetClusterEksConfigV2NodeGroupResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 subnets: Sequence[builtins.str],
                 user_data: builtins.str,
                 version: builtins.str,
                 desired_size: Optional[builtins.int] = None,
                 disk_size: Optional[builtins.int] = None,
                 ec2_ssh_key: Optional[builtins.str] = None,
                 gpu: Optional[builtins.bool] = None,
                 image_id: Optional[builtins.str] = None,
                 instance_type: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 launch_templates: Optional[Sequence['outputs.GetClusterEksConfigV2NodeGroupLaunchTemplateResult']] = None,
                 max_size: Optional[builtins.int] = None,
                 min_size: Optional[builtins.int] = None,
                 node_role: Optional[builtins.str] = None,
                 request_spot_instances: Optional[builtins.bool] = None,
                 resource_tags: Optional[Mapping[str, builtins.str]] = None,
                 spot_instance_types: Optional[Sequence[builtins.str]] = None,
                 tags: Optional[Mapping[str, builtins.str]] = None):
        """
        :param builtins.str name: The name of the Cluster (string)
        :param Sequence[builtins.str] subnets: The EKS node group subnets
        :param builtins.str user_data: The EKS node group user data
        :param builtins.str version: The EKS node group k8s version
        :param builtins.int desired_size: The EKS node group desired size
        :param builtins.int disk_size: The EKS node group disk size
        :param builtins.str ec2_ssh_key: The EKS node group ssh key
        :param builtins.bool gpu: Is EKS cluster using gpu?
        :param builtins.str image_id: The EKS node group image ID
        :param builtins.str instance_type: The EKS node group instance type
        :param Mapping[str, builtins.str] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence['GetClusterEksConfigV2NodeGroupLaunchTemplateArgs'] launch_templates: The EKS node groups launch template
        :param builtins.int max_size: The EKS node group maximum size
        :param builtins.int min_size: The EKS node group minimum size
        :param builtins.str node_role: The EKS node group node role ARN
        :param builtins.bool request_spot_instances: Enable EKS node group request spot instances
        :param Mapping[str, builtins.str] resource_tags: The EKS node group resource tags
        :param Sequence[builtins.str] spot_instance_types: The EKS node group spot instance types
        :param Mapping[str, builtins.str] tags: The EKS node group tags
        """
        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 node_role is not None:
            pulumi.set(__self__, "node_role", node_role)
        if request_spot_instances is not None:
            pulumi.set(__self__, "request_spot_instances", request_spot_instances)
        if resource_tags is not None:
            pulumi.set(__self__, "resource_tags", resource_tags)
        if spot_instance_types is not None:
            pulumi.set(__self__, "spot_instance_types", spot_instance_types)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def subnets(self) -> Sequence[builtins.str]:
        """
        The EKS node group subnets
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> builtins.str:
        """
        The EKS node group user data
        """
        return pulumi.get(self, "user_data")

    @property
    @pulumi.getter
    def version(self) -> builtins.str:
        """
        The EKS node group k8s version
        """
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="desiredSize")
    def desired_size(self) -> Optional[builtins.int]:
        """
        The EKS node group desired size
        """
        return pulumi.get(self, "desired_size")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[builtins.int]:
        """
        The EKS node group disk size
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter(name="ec2SshKey")
    def ec2_ssh_key(self) -> Optional[builtins.str]:
        """
        The EKS node group ssh key
        """
        return pulumi.get(self, "ec2_ssh_key")

    @property
    @pulumi.getter
    def gpu(self) -> Optional[builtins.bool]:
        """
        Is EKS cluster using gpu?
        """
        return pulumi.get(self, "gpu")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[builtins.str]:
        """
        The EKS node group image ID
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        The EKS node group instance type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        (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']]:
        """
        The EKS node groups launch template
        """
        return pulumi.get(self, "launch_templates")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[builtins.int]:
        """
        The EKS node group maximum size
        """
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[builtins.int]:
        """
        The EKS node group minimum size
        """
        return pulumi.get(self, "min_size")

    @property
    @pulumi.getter(name="nodeRole")
    def node_role(self) -> Optional[builtins.str]:
        """
        The EKS node group node role ARN
        """
        return pulumi.get(self, "node_role")

    @property
    @pulumi.getter(name="requestSpotInstances")
    def request_spot_instances(self) -> Optional[builtins.bool]:
        """
        Enable EKS node group request spot instances
        """
        return pulumi.get(self, "request_spot_instances")

    @property
    @pulumi.getter(name="resourceTags")
    def resource_tags(self) -> Optional[Mapping[str, builtins.str]]:
        """
        The EKS node group resource tags
        """
        return pulumi.get(self, "resource_tags")

    @property
    @pulumi.getter(name="spotInstanceTypes")
    def spot_instance_types(self) -> Optional[Sequence[builtins.str]]:
        """
        The EKS node group spot instance types
        """
        return pulumi.get(self, "spot_instance_types")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, builtins.str]]:
        """
        The EKS node group tags
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetClusterEksConfigV2NodeGroupLaunchTemplateResult(dict):
    def __init__(__self__, *,
                 id: builtins.str,
                 name: builtins.str,
                 version: Optional[builtins.int] = None):
        """
        :param builtins.str id: (Computed) The ID of the resource (string)
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.int version: The EKS node group launch template version
        """
        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) -> builtins.str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> Optional[builtins.int]:
        """
        The EKS node group launch template version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterGkeConfigResult(dict):
    def __init__(__self__, *,
                 cluster_ipv4_cidr: builtins.str,
                 credential: builtins.str,
                 disk_type: builtins.str,
                 image_type: builtins.str,
                 ip_policy_cluster_ipv4_cidr_block: builtins.str,
                 ip_policy_cluster_secondary_range_name: builtins.str,
                 ip_policy_node_ipv4_cidr_block: builtins.str,
                 ip_policy_services_ipv4_cidr_block: builtins.str,
                 ip_policy_services_secondary_range_name: builtins.str,
                 ip_policy_subnetwork_name: builtins.str,
                 labels: Mapping[str, builtins.str],
                 locations: Sequence[builtins.str],
                 machine_type: builtins.str,
                 maintenance_window: builtins.str,
                 master_ipv4_cidr_block: builtins.str,
                 master_version: builtins.str,
                 network: builtins.str,
                 node_pool: builtins.str,
                 node_version: builtins.str,
                 oauth_scopes: Sequence[builtins.str],
                 project_id: builtins.str,
                 resource_labels: Mapping[str, builtins.str],
                 service_account: builtins.str,
                 sub_network: builtins.str,
                 description: Optional[builtins.str] = None,
                 disk_size_gb: Optional[builtins.int] = None,
                 enable_alpha_feature: Optional[builtins.bool] = None,
                 enable_auto_repair: Optional[builtins.bool] = None,
                 enable_auto_upgrade: Optional[builtins.bool] = None,
                 enable_horizontal_pod_autoscaling: Optional[builtins.bool] = None,
                 enable_http_load_balancing: Optional[builtins.bool] = None,
                 enable_kubernetes_dashboard: Optional[builtins.bool] = None,
                 enable_legacy_abac: Optional[builtins.bool] = None,
                 enable_master_authorized_network: Optional[builtins.bool] = None,
                 enable_network_policy_config: Optional[builtins.bool] = None,
                 enable_nodepool_autoscaling: Optional[builtins.bool] = None,
                 enable_private_endpoint: Optional[builtins.bool] = None,
                 enable_private_nodes: Optional[builtins.bool] = None,
                 enable_stackdriver_logging: Optional[builtins.bool] = None,
                 enable_stackdriver_monitoring: Optional[builtins.bool] = None,
                 ip_policy_create_subnetwork: Optional[builtins.bool] = None,
                 issue_client_certificate: Optional[builtins.bool] = None,
                 kubernetes_dashboard: Optional[builtins.bool] = None,
                 local_ssd_count: Optional[builtins.int] = None,
                 master_authorized_network_cidr_blocks: Optional[Sequence[builtins.str]] = None,
                 max_node_count: Optional[builtins.int] = None,
                 min_node_count: Optional[builtins.int] = None,
                 node_count: Optional[builtins.int] = None,
                 preemptible: Optional[builtins.bool] = None,
                 region: Optional[builtins.str] = None,
                 taints: Optional[Sequence[builtins.str]] = None,
                 use_ip_aliases: Optional[builtins.bool] = None,
                 zone: Optional[builtins.str] = None):
        """
        :param builtins.str cluster_ipv4_cidr: The IP address range of the container pods
        :param builtins.str credential: The contents of the GC credential file
        :param builtins.str disk_type: Type of the disk attached to each node
        :param builtins.str image_type: The image to use for the worker nodes
        :param builtins.str ip_policy_cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs
        :param builtins.str ip_policy_cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block
        :param builtins.str ip_policy_node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster
        :param builtins.str ip_policy_services_ipv4_cidr_block: The IP address range of the services IPs in this cluster
        :param builtins.str ip_policy_services_secondary_range_name: The name of the secondary range to be used for the services CIDR block
        :param builtins.str ip_policy_subnetwork_name: A custom subnetwork name to be used if createSubnetwork is true
        :param Mapping[str, builtins.str] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence[builtins.str] locations: Locations to use for the cluster
        :param builtins.str machine_type: The machine type to use for the worker nodes
        :param builtins.str maintenance_window: When to performance updates on the nodes, in 24-hour time
        :param builtins.str master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network
        :param builtins.str master_version: The kubernetes master version
        :param builtins.str network: The network to use for the cluster
        :param builtins.str node_pool: The ID of the cluster node pool
        :param builtins.str node_version: The version of kubernetes to use on the nodes
        :param Sequence[builtins.str] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the default service account
        :param builtins.str project_id: The ID of your project to use when creating a cluster
        :param Mapping[str, builtins.str] resource_labels: The map of Kubernetes labels (key/value pairs) to be applied to each cluster
        :param builtins.str service_account: The Google Cloud Platform Service Account to be used by the node VMs
        :param builtins.str sub_network: The sub-network to use for the cluster
        :param builtins.str description: (Computed) The description for Cluster (string)
        :param builtins.int disk_size_gb: Size of the disk attached to each node
        :param builtins.bool enable_alpha_feature: To enable kubernetes alpha feature
        :param builtins.bool enable_auto_repair: Specifies whether the node auto-repair is enabled for the node pool
        :param builtins.bool enable_auto_upgrade: Specifies whether node auto-upgrade is enabled for the node pool
        :param builtins.bool enable_horizontal_pod_autoscaling: Enable horizontal pod autoscaling for the cluster
        :param builtins.bool enable_http_load_balancing: Enable http load balancing for the cluster
        :param builtins.bool enable_kubernetes_dashboard: Whether to enable the kubernetes dashboard
        :param builtins.bool enable_legacy_abac: Whether to enable legacy abac on the cluster
        :param builtins.bool enable_master_authorized_network: Whether or not master authorized network is enabled
        :param builtins.bool enable_network_policy_config: Enable network policy config for the cluster
        :param builtins.bool enable_nodepool_autoscaling: Enable nodepool autoscaling
        :param builtins.bool enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint
        :param builtins.bool enable_private_nodes: Whether nodes have internal IP address only
        :param builtins.bool enable_stackdriver_logging: Enable stackdriver logging
        :param builtins.bool enable_stackdriver_monitoring: Enable stackdriver monitoring
        :param builtins.bool ip_policy_create_subnetwork: Whether a new subnetwork will be created automatically for the cluster
        :param builtins.bool issue_client_certificate: Issue a client certificate
        :param builtins.bool kubernetes_dashboard: Enable the kubernetes dashboard
        :param builtins.int local_ssd_count: The number of local SSD disks to be attached to the node
        :param Sequence[builtins.str] master_authorized_network_cidr_blocks: Define up to 10 external networks that could access Kubernetes master through HTTPS
        :param builtins.int max_node_count: Maximum number of nodes in the NodePool. Must be >= minNodeCount. There has to enough quota to scale up the cluster
        :param builtins.int min_node_count: Minimmum number of nodes in the NodePool. Must be >= 1 and <= maxNodeCount
        :param builtins.int node_count: The number of nodes to create in this cluster
        :param builtins.bool preemptible: Whether the nodes are created as preemptible VM instances
        :param builtins.str region: The region to launch the cluster. Region or zone should be used
        :param Sequence[builtins.str] taints: List of kubernetes taints to be applied to each node
        :param builtins.bool use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster
        :param builtins.str zone: The zone to launch the cluster. Zone or region should be used
        """
        pulumi.set(__self__, "cluster_ipv4_cidr", cluster_ipv4_cidr)
        pulumi.set(__self__, "credential", credential)
        pulumi.set(__self__, "disk_type", disk_type)
        pulumi.set(__self__, "image_type", image_type)
        pulumi.set(__self__, "ip_policy_cluster_ipv4_cidr_block", ip_policy_cluster_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_cluster_secondary_range_name", ip_policy_cluster_secondary_range_name)
        pulumi.set(__self__, "ip_policy_node_ipv4_cidr_block", ip_policy_node_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_services_ipv4_cidr_block", ip_policy_services_ipv4_cidr_block)
        pulumi.set(__self__, "ip_policy_services_secondary_range_name", ip_policy_services_secondary_range_name)
        pulumi.set(__self__, "ip_policy_subnetwork_name", ip_policy_subnetwork_name)
        pulumi.set(__self__, "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) -> builtins.str:
        """
        The IP address range of the container pods
        """
        return pulumi.get(self, "cluster_ipv4_cidr")

    @property
    @pulumi.getter
    def credential(self) -> builtins.str:
        """
        The contents of the GC credential file
        """
        return pulumi.get(self, "credential")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> builtins.str:
        """
        Type of the disk attached to each node
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> builtins.str:
        """
        The image to use for the worker nodes
        """
        return pulumi.get(self, "image_type")

    @property
    @pulumi.getter(name="ipPolicyClusterIpv4CidrBlock")
    def ip_policy_cluster_ipv4_cidr_block(self) -> builtins.str:
        """
        The IP address range for the cluster pod IPs
        """
        return pulumi.get(self, "ip_policy_cluster_ipv4_cidr_block")

    @property
    @pulumi.getter(name="ipPolicyClusterSecondaryRangeName")
    def ip_policy_cluster_secondary_range_name(self) -> builtins.str:
        """
        The name of the secondary range to be used for the cluster CIDR block
        """
        return pulumi.get(self, "ip_policy_cluster_secondary_range_name")

    @property
    @pulumi.getter(name="ipPolicyNodeIpv4CidrBlock")
    def ip_policy_node_ipv4_cidr_block(self) -> builtins.str:
        """
        The IP address range of the instance IPs in this cluster
        """
        return pulumi.get(self, "ip_policy_node_ipv4_cidr_block")

    @property
    @pulumi.getter(name="ipPolicyServicesIpv4CidrBlock")
    def ip_policy_services_ipv4_cidr_block(self) -> builtins.str:
        """
        The IP address range of the services IPs in this cluster
        """
        return pulumi.get(self, "ip_policy_services_ipv4_cidr_block")

    @property
    @pulumi.getter(name="ipPolicyServicesSecondaryRangeName")
    def ip_policy_services_secondary_range_name(self) -> builtins.str:
        """
        The name of the secondary range to be used for the services CIDR block
        """
        return pulumi.get(self, "ip_policy_services_secondary_range_name")

    @property
    @pulumi.getter(name="ipPolicySubnetworkName")
    def ip_policy_subnetwork_name(self) -> builtins.str:
        """
        A custom subnetwork name to be used if createSubnetwork is true
        """
        return pulumi.get(self, "ip_policy_subnetwork_name")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def locations(self) -> Sequence[builtins.str]:
        """
        Locations to use for the cluster
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> builtins.str:
        """
        The machine type to use for the worker nodes
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> builtins.str:
        """
        When to performance updates on the nodes, in 24-hour time
        """
        return pulumi.get(self, "maintenance_window")

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> builtins.str:
        """
        The IP range in CIDR notation to use for the hosted master network
        """
        return pulumi.get(self, "master_ipv4_cidr_block")

    @property
    @pulumi.getter(name="masterVersion")
    def master_version(self) -> builtins.str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "master_version")

    @property
    @pulumi.getter
    def network(self) -> builtins.str:
        """
        The network to use for the cluster
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nodePool")
    def node_pool(self) -> builtins.str:
        """
        The ID of the cluster node pool
        """
        return pulumi.get(self, "node_pool")

    @property
    @pulumi.getter(name="nodeVersion")
    def node_version(self) -> builtins.str:
        """
        The version of kubernetes to use on the nodes
        """
        return pulumi.get(self, "node_version")

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Sequence[builtins.str]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the default service account
        """
        return pulumi.get(self, "oauth_scopes")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        The ID of your project to use when creating a cluster
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="resourceLabels")
    def resource_labels(self) -> Mapping[str, builtins.str]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each cluster
        """
        return pulumi.get(self, "resource_labels")

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> builtins.str:
        """
        The Google Cloud Platform Service Account to be used by the node VMs
        """
        return pulumi.get(self, "service_account")

    @property
    @pulumi.getter(name="subNetwork")
    def sub_network(self) -> builtins.str:
        """
        The sub-network to use for the cluster
        """
        return pulumi.get(self, "sub_network")

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[builtins.int]:
        """
        Size of the disk attached to each node
        """
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="enableAlphaFeature")
    def enable_alpha_feature(self) -> Optional[builtins.bool]:
        """
        To enable kubernetes alpha feature
        """
        return pulumi.get(self, "enable_alpha_feature")

    @property
    @pulumi.getter(name="enableAutoRepair")
    def enable_auto_repair(self) -> Optional[builtins.bool]:
        """
        Specifies whether the node auto-repair is enabled for the node pool
        """
        return pulumi.get(self, "enable_auto_repair")

    @property
    @pulumi.getter(name="enableAutoUpgrade")
    def enable_auto_upgrade(self) -> Optional[builtins.bool]:
        """
        Specifies whether node auto-upgrade is enabled for the node pool
        """
        return pulumi.get(self, "enable_auto_upgrade")

    @property
    @pulumi.getter(name="enableHorizontalPodAutoscaling")
    def enable_horizontal_pod_autoscaling(self) -> Optional[builtins.bool]:
        """
        Enable horizontal pod autoscaling for the cluster
        """
        return pulumi.get(self, "enable_horizontal_pod_autoscaling")

    @property
    @pulumi.getter(name="enableHttpLoadBalancing")
    def enable_http_load_balancing(self) -> Optional[builtins.bool]:
        """
        Enable http load balancing for the cluster
        """
        return pulumi.get(self, "enable_http_load_balancing")

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[builtins.bool]:
        """
        Whether to enable the kubernetes dashboard
        """
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @property
    @pulumi.getter(name="enableLegacyAbac")
    def enable_legacy_abac(self) -> Optional[builtins.bool]:
        """
        Whether to enable legacy abac on the cluster
        """
        return pulumi.get(self, "enable_legacy_abac")

    @property
    @pulumi.getter(name="enableMasterAuthorizedNetwork")
    def enable_master_authorized_network(self) -> Optional[builtins.bool]:
        """
        Whether or not master authorized network is enabled
        """
        return pulumi.get(self, "enable_master_authorized_network")

    @property
    @pulumi.getter(name="enableNetworkPolicyConfig")
    def enable_network_policy_config(self) -> Optional[builtins.bool]:
        """
        Enable network policy config for the cluster
        """
        return pulumi.get(self, "enable_network_policy_config")

    @property
    @pulumi.getter(name="enableNodepoolAutoscaling")
    def enable_nodepool_autoscaling(self) -> Optional[builtins.bool]:
        """
        Enable nodepool autoscaling
        """
        return pulumi.get(self, "enable_nodepool_autoscaling")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[builtins.bool]:
        """
        Whether the master's internal IP address is used as the cluster endpoint
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[builtins.bool]:
        """
        Whether nodes have internal IP address only
        """
        return pulumi.get(self, "enable_private_nodes")

    @property
    @pulumi.getter(name="enableStackdriverLogging")
    def enable_stackdriver_logging(self) -> Optional[builtins.bool]:
        """
        Enable stackdriver logging
        """
        return pulumi.get(self, "enable_stackdriver_logging")

    @property
    @pulumi.getter(name="enableStackdriverMonitoring")
    def enable_stackdriver_monitoring(self) -> Optional[builtins.bool]:
        """
        Enable stackdriver monitoring
        """
        return pulumi.get(self, "enable_stackdriver_monitoring")

    @property
    @pulumi.getter(name="ipPolicyCreateSubnetwork")
    def ip_policy_create_subnetwork(self) -> Optional[builtins.bool]:
        """
        Whether a new subnetwork will be created automatically for the cluster
        """
        return pulumi.get(self, "ip_policy_create_subnetwork")

    @property
    @pulumi.getter(name="issueClientCertificate")
    def issue_client_certificate(self) -> Optional[builtins.bool]:
        """
        Issue a client certificate
        """
        return pulumi.get(self, "issue_client_certificate")

    @property
    @pulumi.getter(name="kubernetesDashboard")
    def kubernetes_dashboard(self) -> Optional[builtins.bool]:
        """
        Enable the kubernetes dashboard
        """
        return pulumi.get(self, "kubernetes_dashboard")

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[builtins.int]:
        """
        The number of local SSD disks to be attached to the node
        """
        return pulumi.get(self, "local_ssd_count")

    @property
    @pulumi.getter(name="masterAuthorizedNetworkCidrBlocks")
    def master_authorized_network_cidr_blocks(self) -> Optional[Sequence[builtins.str]]:
        """
        Define up to 10 external networks that could access Kubernetes master through HTTPS
        """
        return pulumi.get(self, "master_authorized_network_cidr_blocks")

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> Optional[builtins.int]:
        """
        Maximum number of nodes in the NodePool. Must be >= minNodeCount. There has to enough quota to scale up the cluster
        """
        return pulumi.get(self, "max_node_count")

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[builtins.int]:
        """
        Minimmum number of nodes in the NodePool. Must be >= 1 and <= maxNodeCount
        """
        return pulumi.get(self, "min_node_count")

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[builtins.int]:
        """
        The number of nodes to create in this cluster
        """
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[builtins.bool]:
        """
        Whether the nodes are created as preemptible VM instances
        """
        return pulumi.get(self, "preemptible")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        The region to launch the cluster. Region or zone should be used
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence[builtins.str]]:
        """
        List of kubernetes taints to be applied to each node
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[builtins.bool]:
        """
        Whether alias IPs will be used for pod IPs in the cluster
        """
        return pulumi.get(self, "use_ip_aliases")

    @property
    @pulumi.getter
    def zone(self) -> Optional[builtins.str]:
        """
        The zone to launch the cluster. Zone or region should be used
        """
        return pulumi.get(self, "zone")


@pulumi.output_type
class GetClusterGkeConfigV2Result(dict):
    def __init__(__self__, *,
                 cluster_addons: 'outputs.GetClusterGkeConfigV2ClusterAddonsResult',
                 cluster_ipv4_cidr_block: builtins.str,
                 description: builtins.str,
                 enable_kubernetes_alpha: builtins.bool,
                 google_credential_secret: builtins.str,
                 ip_allocation_policy: 'outputs.GetClusterGkeConfigV2IpAllocationPolicyResult',
                 kubernetes_version: builtins.str,
                 labels: Mapping[str, builtins.str],
                 locations: Sequence[builtins.str],
                 logging_service: builtins.str,
                 maintenance_window: builtins.str,
                 master_authorized_networks_config: 'outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult',
                 monitoring_service: builtins.str,
                 name: builtins.str,
                 network: builtins.str,
                 network_policy_enabled: builtins.bool,
                 node_pools: Sequence['outputs.GetClusterGkeConfigV2NodePoolResult'],
                 private_cluster_config: 'outputs.GetClusterGkeConfigV2PrivateClusterConfigResult',
                 project_id: builtins.str,
                 region: builtins.str,
                 subnetwork: builtins.str,
                 zone: builtins.str,
                 imported: Optional[builtins.bool] = None):
        """
        :param 'GetClusterGkeConfigV2ClusterAddonsArgs' cluster_addons: The GKE cluster addons
        :param builtins.str cluster_ipv4_cidr_block: The GKE ip v4 cidr block
        :param builtins.str description: (Computed) The description for Cluster (string)
        :param builtins.bool enable_kubernetes_alpha: Enable Kubernetes alpha
        :param builtins.str google_credential_secret: Google credential secret
        :param 'GetClusterGkeConfigV2IpAllocationPolicyArgs' ip_allocation_policy: The GKE ip allocation policy
        :param builtins.str kubernetes_version: The kubernetes master version
        :param Mapping[str, builtins.str] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence[builtins.str] locations: The GKE cluster locations
        :param builtins.str logging_service: The GKE cluster logging service
        :param builtins.str maintenance_window: The GKE cluster maintenance window
        :param 'GetClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs' master_authorized_networks_config: The GKE cluster master authorized networks config
        :param builtins.str monitoring_service: The GKE cluster monitoring service
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str network: The GKE cluster network
        :param builtins.bool network_policy_enabled: Is GKE cluster network policy enabled?
        :param Sequence['GetClusterGkeConfigV2NodePoolArgs'] node_pools: The GKE cluster node pools
        :param 'GetClusterGkeConfigV2PrivateClusterConfigArgs' private_cluster_config: The GKE private cluster config
        :param builtins.str project_id: The GKE project id
        :param builtins.str region: The GKE cluster region. Required if `zone` is empty
        :param builtins.str subnetwork: The GKE cluster subnetwork
        :param builtins.str zone: The GKE cluster zone. Required if `region` is empty
        :param builtins.bool imported: Is GKE cluster imported?
        """
        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':
        """
        The GKE cluster addons
        """
        return pulumi.get(self, "cluster_addons")

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> builtins.str:
        """
        The GKE ip v4 cidr block
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableKubernetesAlpha")
    def enable_kubernetes_alpha(self) -> builtins.bool:
        """
        Enable Kubernetes alpha
        """
        return pulumi.get(self, "enable_kubernetes_alpha")

    @property
    @pulumi.getter(name="googleCredentialSecret")
    def google_credential_secret(self) -> builtins.str:
        """
        Google credential secret
        """
        return pulumi.get(self, "google_credential_secret")

    @property
    @pulumi.getter(name="ipAllocationPolicy")
    def ip_allocation_policy(self) -> 'outputs.GetClusterGkeConfigV2IpAllocationPolicyResult':
        """
        The GKE ip allocation policy
        """
        return pulumi.get(self, "ip_allocation_policy")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def locations(self) -> Sequence[builtins.str]:
        """
        The GKE cluster locations
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter(name="loggingService")
    def logging_service(self) -> builtins.str:
        """
        The GKE cluster logging service
        """
        return pulumi.get(self, "logging_service")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> builtins.str:
        """
        The GKE cluster maintenance window
        """
        return pulumi.get(self, "maintenance_window")

    @property
    @pulumi.getter(name="masterAuthorizedNetworksConfig")
    def master_authorized_networks_config(self) -> 'outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult':
        """
        The GKE cluster master authorized networks config
        """
        return pulumi.get(self, "master_authorized_networks_config")

    @property
    @pulumi.getter(name="monitoringService")
    def monitoring_service(self) -> builtins.str:
        """
        The GKE cluster monitoring service
        """
        return pulumi.get(self, "monitoring_service")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> builtins.str:
        """
        The GKE cluster network
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="networkPolicyEnabled")
    def network_policy_enabled(self) -> builtins.bool:
        """
        Is GKE cluster network policy enabled?
        """
        return pulumi.get(self, "network_policy_enabled")

    @property
    @pulumi.getter(name="nodePools")
    def node_pools(self) -> Sequence['outputs.GetClusterGkeConfigV2NodePoolResult']:
        """
        The GKE cluster node pools
        """
        return pulumi.get(self, "node_pools")

    @property
    @pulumi.getter(name="privateClusterConfig")
    def private_cluster_config(self) -> 'outputs.GetClusterGkeConfigV2PrivateClusterConfigResult':
        """
        The GKE private cluster config
        """
        return pulumi.get(self, "private_cluster_config")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        The GKE project id
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        """
        The GKE cluster region. Required if `zone` is empty
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def subnetwork(self) -> builtins.str:
        """
        The GKE cluster subnetwork
        """
        return pulumi.get(self, "subnetwork")

    @property
    @pulumi.getter
    def zone(self) -> builtins.str:
        """
        The GKE cluster zone. Required if `region` is empty
        """
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter
    def imported(self) -> Optional[builtins.bool]:
        """
        Is GKE cluster imported?
        """
        return pulumi.get(self, "imported")


@pulumi.output_type
class GetClusterGkeConfigV2ClusterAddonsResult(dict):
    def __init__(__self__, *,
                 horizontal_pod_autoscaling: builtins.bool,
                 http_load_balancing: builtins.bool,
                 network_policy_config: builtins.bool):
        """
        :param builtins.bool horizontal_pod_autoscaling: Enable GKE horizontal pod autoscaling
        :param builtins.bool http_load_balancing: Enable GKE HTTP load balancing
        :param builtins.bool network_policy_config: Enable GKE network policy config
        """
        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) -> builtins.bool:
        """
        Enable GKE horizontal pod autoscaling
        """
        return pulumi.get(self, "horizontal_pod_autoscaling")

    @property
    @pulumi.getter(name="httpLoadBalancing")
    def http_load_balancing(self) -> builtins.bool:
        """
        Enable GKE HTTP load balancing
        """
        return pulumi.get(self, "http_load_balancing")

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> builtins.bool:
        """
        Enable GKE network policy config
        """
        return pulumi.get(self, "network_policy_config")


@pulumi.output_type
class GetClusterGkeConfigV2IpAllocationPolicyResult(dict):
    def __init__(__self__, *,
                 cluster_ipv4_cidr_block: builtins.str,
                 cluster_secondary_range_name: builtins.str,
                 create_subnetwork: builtins.bool,
                 node_ipv4_cidr_block: builtins.str,
                 services_ipv4_cidr_block: builtins.str,
                 services_secondary_range_name: builtins.str,
                 subnetwork_name: builtins.str,
                 use_ip_aliases: builtins.bool):
        """
        :param builtins.str cluster_ipv4_cidr_block: The GKE cluster ip v4 allocation cidr block
        :param builtins.str cluster_secondary_range_name: The GKE cluster ip v4 allocation secondary range name
        :param builtins.bool create_subnetwork: Create GKE subnetwork?
        :param builtins.str node_ipv4_cidr_block: The GKE node ip v4 allocation cidr block
        :param builtins.str services_ipv4_cidr_block: The GKE services ip v4 allocation cidr block
        :param builtins.str services_secondary_range_name: The GKE services ip v4 allocation secondary range name
        :param builtins.str subnetwork_name: The GKE cluster subnetwork name
        :param builtins.bool use_ip_aliases: Use GKE ip aliases?
        """
        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) -> builtins.str:
        """
        The GKE cluster ip v4 allocation cidr block
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @property
    @pulumi.getter(name="clusterSecondaryRangeName")
    def cluster_secondary_range_name(self) -> builtins.str:
        """
        The GKE cluster ip v4 allocation secondary range name
        """
        return pulumi.get(self, "cluster_secondary_range_name")

    @property
    @pulumi.getter(name="createSubnetwork")
    def create_subnetwork(self) -> builtins.bool:
        """
        Create GKE subnetwork?
        """
        return pulumi.get(self, "create_subnetwork")

    @property
    @pulumi.getter(name="nodeIpv4CidrBlock")
    def node_ipv4_cidr_block(self) -> builtins.str:
        """
        The GKE node ip v4 allocation cidr block
        """
        return pulumi.get(self, "node_ipv4_cidr_block")

    @property
    @pulumi.getter(name="servicesIpv4CidrBlock")
    def services_ipv4_cidr_block(self) -> builtins.str:
        """
        The GKE services ip v4 allocation cidr block
        """
        return pulumi.get(self, "services_ipv4_cidr_block")

    @property
    @pulumi.getter(name="servicesSecondaryRangeName")
    def services_secondary_range_name(self) -> builtins.str:
        """
        The GKE services ip v4 allocation secondary range name
        """
        return pulumi.get(self, "services_secondary_range_name")

    @property
    @pulumi.getter(name="subnetworkName")
    def subnetwork_name(self) -> builtins.str:
        """
        The GKE cluster subnetwork name
        """
        return pulumi.get(self, "subnetwork_name")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> builtins.bool:
        """
        Use GKE ip aliases?
        """
        return pulumi.get(self, "use_ip_aliases")


@pulumi.output_type
class GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult(dict):
    def __init__(__self__, *,
                 cidr_blocks: Sequence['outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult'],
                 enabled: Optional[builtins.bool] = None):
        """
        :param Sequence['GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs'] cidr_blocks: The GKE master authorized network config cidr blocks
        :param builtins.bool enabled: Enable GKE master authorized network config
        """
        pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> Sequence['outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult']:
        """
        The GKE master authorized network config cidr blocks
        """
        return pulumi.get(self, "cidr_blocks")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable GKE master authorized network config
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult(dict):
    def __init__(__self__, *,
                 cidr_block: builtins.str,
                 display_name: Optional[builtins.str] = None):
        """
        :param builtins.str cidr_block: The GKE master authorized network config cidr block
        :param builtins.str display_name: The GKE master authorized network config cidr block dispaly name
        """
        pulumi.set(__self__, "cidr_block", cidr_block)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> builtins.str:
        """
        The GKE master authorized network config cidr block
        """
        return pulumi.get(self, "cidr_block")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[builtins.str]:
        """
        The GKE master authorized network config cidr block dispaly name
        """
        return pulumi.get(self, "display_name")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolResult(dict):
    def __init__(__self__, *,
                 autoscaling: 'outputs.GetClusterGkeConfigV2NodePoolAutoscalingResult',
                 config: 'outputs.GetClusterGkeConfigV2NodePoolConfigResult',
                 initial_node_count: builtins.int,
                 management: 'outputs.GetClusterGkeConfigV2NodePoolManagementResult',
                 max_pods_constraint: builtins.int,
                 name: builtins.str,
                 version: builtins.str):
        """
        :param 'GetClusterGkeConfigV2NodePoolAutoscalingArgs' autoscaling: The GKE node pool config autoscaling
        :param 'GetClusterGkeConfigV2NodePoolConfigArgs' config: The GKE node pool node config
        :param builtins.int initial_node_count: The GKE node pool config initial node count
        :param 'GetClusterGkeConfigV2NodePoolManagementArgs' management: The GKE node pool config management
        :param builtins.int max_pods_constraint: The GKE node pool config max pods constraint
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str version: The GKE node pool config version
        """
        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':
        """
        The GKE node pool config autoscaling
        """
        return pulumi.get(self, "autoscaling")

    @property
    @pulumi.getter
    def config(self) -> 'outputs.GetClusterGkeConfigV2NodePoolConfigResult':
        """
        The GKE node pool node config
        """
        return pulumi.get(self, "config")

    @property
    @pulumi.getter(name="initialNodeCount")
    def initial_node_count(self) -> builtins.int:
        """
        The GKE node pool config initial node count
        """
        return pulumi.get(self, "initial_node_count")

    @property
    @pulumi.getter
    def management(self) -> 'outputs.GetClusterGkeConfigV2NodePoolManagementResult':
        """
        The GKE node pool config management
        """
        return pulumi.get(self, "management")

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> builtins.int:
        """
        The GKE node pool config max pods constraint
        """
        return pulumi.get(self, "max_pods_constraint")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> builtins.str:
        """
        The GKE node pool config version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolAutoscalingResult(dict):
    def __init__(__self__, *,
                 max_node_count: builtins.int,
                 min_node_count: builtins.int,
                 enabled: Optional[builtins.bool] = None):
        """
        :param builtins.int max_node_count: The GKE node pool config max node count
        :param builtins.int min_node_count: The GKE node pool config min node count
        :param builtins.bool enabled: Enable GKE node pool config autoscaling
        """
        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) -> builtins.int:
        """
        The GKE node pool config max node count
        """
        return pulumi.get(self, "max_node_count")

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> builtins.int:
        """
        The GKE node pool config min node count
        """
        return pulumi.get(self, "min_node_count")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable GKE node pool config autoscaling
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolConfigResult(dict):
    def __init__(__self__, *,
                 labels: Mapping[str, builtins.str],
                 oauth_scopes: Sequence[builtins.str],
                 tags: Sequence[builtins.str],
                 disk_size_gb: Optional[builtins.int] = None,
                 disk_type: Optional[builtins.str] = None,
                 image_type: Optional[builtins.str] = None,
                 local_ssd_count: Optional[builtins.int] = None,
                 machine_type: Optional[builtins.str] = None,
                 preemptible: Optional[builtins.bool] = None,
                 service_account: Optional[builtins.str] = None,
                 taints: Optional[Sequence['outputs.GetClusterGkeConfigV2NodePoolConfigTaintResult']] = None):
        """
        :param Mapping[str, builtins.str] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence[builtins.str] oauth_scopes: The GKE node config oauth scopes
        :param Sequence[builtins.str] tags: The GKE node config tags
        :param builtins.int disk_size_gb: The GKE node config disk size (Gb)
        :param builtins.str disk_type: The GKE node config disk type
        :param builtins.str image_type: The GKE node config image type
        :param builtins.int local_ssd_count: The GKE node config local ssd count
        :param builtins.str machine_type: The GKE node config machine type
        :param builtins.bool preemptible: Enable GKE node config preemptible
        :param builtins.str service_account: The GKE node config service account
        :param Sequence['GetClusterGkeConfigV2NodePoolConfigTaintArgs'] taints: The GKE node config taints
        """
        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 service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Sequence[builtins.str]:
        """
        The GKE node config oauth scopes
        """
        return pulumi.get(self, "oauth_scopes")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[builtins.str]:
        """
        The GKE node config tags
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[builtins.int]:
        """
        The GKE node config disk size (Gb)
        """
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[builtins.str]:
        """
        The GKE node config disk type
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[builtins.str]:
        """
        The GKE node config image type
        """
        return pulumi.get(self, "image_type")

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[builtins.int]:
        """
        The GKE node config local ssd count
        """
        return pulumi.get(self, "local_ssd_count")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[builtins.str]:
        """
        The GKE node config machine type
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[builtins.bool]:
        """
        Enable GKE node config preemptible
        """
        return pulumi.get(self, "preemptible")

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[builtins.str]:
        """
        The GKE node config service account
        """
        return pulumi.get(self, "service_account")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence['outputs.GetClusterGkeConfigV2NodePoolConfigTaintResult']]:
        """
        The GKE node config taints
        """
        return pulumi.get(self, "taints")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolConfigTaintResult(dict):
    def __init__(__self__, *,
                 effect: builtins.str,
                 key: builtins.str,
                 value: builtins.str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> builtins.str:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolManagementResult(dict):
    def __init__(__self__, *,
                 auto_repair: builtins.bool,
                 auto_upgrade: builtins.bool):
        """
        :param builtins.bool auto_repair: Enable GKE node pool config management auto repair
        :param builtins.bool auto_upgrade: Enable GKE node pool config management auto upgrade
        """
        pulumi.set(__self__, "auto_repair", auto_repair)
        pulumi.set(__self__, "auto_upgrade", auto_upgrade)

    @property
    @pulumi.getter(name="autoRepair")
    def auto_repair(self) -> builtins.bool:
        """
        Enable GKE node pool config management auto repair
        """
        return pulumi.get(self, "auto_repair")

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> builtins.bool:
        """
        Enable GKE node pool config management auto upgrade
        """
        return pulumi.get(self, "auto_upgrade")


@pulumi.output_type
class GetClusterGkeConfigV2PrivateClusterConfigResult(dict):
    def __init__(__self__, *,
                 master_ipv4_cidr_block: builtins.str,
                 enable_private_endpoint: Optional[builtins.bool] = None,
                 enable_private_nodes: Optional[builtins.bool] = None):
        """
        :param builtins.str master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block
        :param builtins.bool enable_private_endpoint: Enable GKE cluster private endpoint
        :param builtins.bool enable_private_nodes: Enable GKE cluster private nodes
        """
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> builtins.str:
        """
        The GKE cluster private master ip v4 cidr block
        """
        return pulumi.get(self, "master_ipv4_cidr_block")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[builtins.bool]:
        """
        Enable GKE cluster private endpoint
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[builtins.bool]:
        """
        Enable GKE cluster private nodes
        """
        return pulumi.get(self, "enable_private_nodes")


@pulumi.output_type
class GetClusterK3sConfigResult(dict):
    def __init__(__self__, *,
                 upgrade_strategy: 'outputs.GetClusterK3sConfigUpgradeStrategyResult',
                 version: builtins.str):
        """
        :param 'GetClusterK3sConfigUpgradeStrategyArgs' upgrade_strategy: The K3S upgrade strategy
        :param builtins.str version: The K3S kubernetes version
        """
        pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterK3sConfigUpgradeStrategyResult':
        """
        The K3S upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter
    def version(self) -> builtins.str:
        """
        The K3S kubernetes version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterK3sConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_server_nodes: Optional[builtins.bool] = None,
                 drain_worker_nodes: Optional[builtins.bool] = None,
                 server_concurrency: Optional[builtins.int] = None,
                 worker_concurrency: Optional[builtins.int] = None):
        """
        :param builtins.bool drain_server_nodes: Drain server nodes
        :param builtins.bool drain_worker_nodes: Drain worker nodes
        :param builtins.int server_concurrency: Server concurrency
        :param builtins.int worker_concurrency: Worker concurrency
        """
        if drain_server_nodes is not None:
            pulumi.set(__self__, "drain_server_nodes", drain_server_nodes)
        if drain_worker_nodes is not None:
            pulumi.set(__self__, "drain_worker_nodes", drain_worker_nodes)
        if server_concurrency is not None:
            pulumi.set(__self__, "server_concurrency", server_concurrency)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)

    @property
    @pulumi.getter(name="drainServerNodes")
    def drain_server_nodes(self) -> Optional[builtins.bool]:
        """
        Drain server nodes
        """
        return pulumi.get(self, "drain_server_nodes")

    @property
    @pulumi.getter(name="drainWorkerNodes")
    def drain_worker_nodes(self) -> Optional[builtins.bool]:
        """
        Drain worker nodes
        """
        return pulumi.get(self, "drain_worker_nodes")

    @property
    @pulumi.getter(name="serverConcurrency")
    def server_concurrency(self) -> Optional[builtins.int]:
        """
        Server concurrency
        """
        return pulumi.get(self, "server_concurrency")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[builtins.int]:
        """
        Worker concurrency
        """
        return pulumi.get(self, "worker_concurrency")


@pulumi.output_type
class GetClusterOkeConfigResult(dict):
    def __init__(__self__, *,
                 compartment_id: builtins.str,
                 fingerprint: builtins.str,
                 kubernetes_version: builtins.str,
                 node_image: builtins.str,
                 node_shape: builtins.str,
                 private_key_contents: builtins.str,
                 region: builtins.str,
                 tenancy_id: builtins.str,
                 user_ocid: builtins.str,
                 custom_boot_volume_size: Optional[builtins.int] = None,
                 description: Optional[builtins.str] = None,
                 enable_kubernetes_dashboard: Optional[builtins.bool] = None,
                 enable_private_control_plane: Optional[builtins.bool] = None,
                 enable_private_nodes: Optional[builtins.bool] = None,
                 flex_ocpus: Optional[builtins.int] = None,
                 kms_key_id: Optional[builtins.str] = None,
                 limit_node_count: Optional[builtins.int] = None,
                 load_balancer_subnet_name1: Optional[builtins.str] = None,
                 load_balancer_subnet_name2: Optional[builtins.str] = None,
                 node_pool_dns_domain_name: Optional[builtins.str] = None,
                 node_pool_subnet_name: Optional[builtins.str] = None,
                 node_public_key_contents: Optional[builtins.str] = None,
                 pod_cidr: Optional[builtins.str] = None,
                 private_key_passphrase: Optional[builtins.str] = None,
                 quantity_of_node_subnets: Optional[builtins.int] = None,
                 quantity_per_subnet: Optional[builtins.int] = None,
                 service_cidr: Optional[builtins.str] = None,
                 service_dns_domain_name: Optional[builtins.str] = None,
                 skip_vcn_delete: Optional[builtins.bool] = None,
                 vcn_compartment_id: Optional[builtins.str] = None,
                 vcn_name: Optional[builtins.str] = None,
                 worker_node_ingress_cidr: Optional[builtins.str] = None):
        """
        :param builtins.str compartment_id: The OCID of the compartment in which to create resources (VCN, worker nodes, etc.)
        :param builtins.str fingerprint: The fingerprint corresponding to the specified user's private API Key
        :param builtins.str kubernetes_version: The Kubernetes version that will be used for your master *and* worker nodes e.g. v1.19.7
        :param builtins.str node_image: The OS for the node image
        :param builtins.str node_shape: The shape of the node (determines number of CPUs and  amount of memory on each node)
        :param builtins.str private_key_contents: The private API key file contents for the specified user, in PEM format
        :param builtins.str region: The availability domain within the region to host the OKE cluster
        :param builtins.str tenancy_id: The OCID of the tenancy in which to create resources
        :param builtins.str user_ocid: The OCID of a user who has access to the tenancy/compartment
        :param builtins.int custom_boot_volume_size: An optional custom boot volume size (in GB) for the nodes
        :param builtins.str description: (Computed) The description for Cluster (string)
        :param builtins.bool enable_kubernetes_dashboard: Enable the kubernetes dashboard
        :param builtins.bool enable_private_control_plane: Whether Kubernetes API endpoint is a private IP only accessible from within the VCN
        :param builtins.bool enable_private_nodes: Whether worker nodes are deployed into a new private subnet
        :param builtins.int flex_ocpus: Optional number of OCPUs for nodes (requires flexible node_shape)
        :param builtins.str kms_key_id: Optional specify the OCID of the KMS Vault master key
        :param builtins.int limit_node_count: Optional limit on the total number of nodes in the pool
        :param builtins.str load_balancer_subnet_name1: The name of the first existing subnet to use for Kubernetes services / LB
        :param builtins.str load_balancer_subnet_name2: The (optional) name of a second existing subnet to use for Kubernetes services / LB
        :param builtins.str node_pool_dns_domain_name: Optional name for DNS domain of node pool subnet
        :param builtins.str node_pool_subnet_name: Optional name for node pool subnet
        :param builtins.str node_public_key_contents: The contents of the SSH public key file to use for the nodes
        :param builtins.str pod_cidr: Optional specify the pod CIDR, defaults to 10.244.0.0/16
        :param builtins.str private_key_passphrase: The passphrase of the private key for the OKE cluster
        :param builtins.int quantity_of_node_subnets: Number of node subnets (defaults to creating 1 regional subnet)
        :param builtins.int quantity_per_subnet: Number of worker nodes in each subnet / availability domain
        :param builtins.str service_cidr: Optional specify the service CIDR, defaults to 10.96.0.0/16
        :param builtins.str service_dns_domain_name: Optional name for DNS domain of service subnet
        :param builtins.bool skip_vcn_delete: Whether to skip deleting VCN
        :param builtins.str vcn_compartment_id: The OCID of the compartment (if different from compartment_id) in which to find the pre-existing virtual network set with vcn_name.
        :param builtins.str vcn_name: The optional name of an existing virtual network to use for the cluster creation. A new VCN will be created if not specified.
        :param builtins.str worker_node_ingress_cidr: Additional CIDR from which to allow ingress to worker nodes
        """
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "fingerprint", fingerprint)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "node_image", node_image)
        pulumi.set(__self__, "node_shape", node_shape)
        pulumi.set(__self__, "private_key_contents", private_key_contents)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenancy_id", tenancy_id)
        pulumi.set(__self__, "user_ocid", user_ocid)
        if custom_boot_volume_size is not None:
            pulumi.set(__self__, "custom_boot_volume_size", custom_boot_volume_size)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_kubernetes_dashboard is not None:
            pulumi.set(__self__, "enable_kubernetes_dashboard", enable_kubernetes_dashboard)
        if enable_private_control_plane is not None:
            pulumi.set(__self__, "enable_private_control_plane", enable_private_control_plane)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if flex_ocpus is not None:
            pulumi.set(__self__, "flex_ocpus", flex_ocpus)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if limit_node_count is not None:
            pulumi.set(__self__, "limit_node_count", limit_node_count)
        if load_balancer_subnet_name1 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name1", load_balancer_subnet_name1)
        if load_balancer_subnet_name2 is not None:
            pulumi.set(__self__, "load_balancer_subnet_name2", load_balancer_subnet_name2)
        if node_pool_dns_domain_name is not None:
            pulumi.set(__self__, "node_pool_dns_domain_name", node_pool_dns_domain_name)
        if node_pool_subnet_name is not None:
            pulumi.set(__self__, "node_pool_subnet_name", node_pool_subnet_name)
        if node_public_key_contents is not None:
            pulumi.set(__self__, "node_public_key_contents", node_public_key_contents)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if private_key_passphrase is not None:
            pulumi.set(__self__, "private_key_passphrase", private_key_passphrase)
        if quantity_of_node_subnets is not None:
            pulumi.set(__self__, "quantity_of_node_subnets", quantity_of_node_subnets)
        if quantity_per_subnet is not None:
            pulumi.set(__self__, "quantity_per_subnet", quantity_per_subnet)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)
        if service_dns_domain_name is not None:
            pulumi.set(__self__, "service_dns_domain_name", service_dns_domain_name)
        if skip_vcn_delete is not None:
            pulumi.set(__self__, "skip_vcn_delete", skip_vcn_delete)
        if vcn_compartment_id is not None:
            pulumi.set(__self__, "vcn_compartment_id", vcn_compartment_id)
        if vcn_name is not None:
            pulumi.set(__self__, "vcn_name", vcn_name)
        if worker_node_ingress_cidr is not None:
            pulumi.set(__self__, "worker_node_ingress_cidr", worker_node_ingress_cidr)

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> builtins.str:
        """
        The OCID of the compartment in which to create resources (VCN, worker nodes, etc.)
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter
    def fingerprint(self) -> builtins.str:
        """
        The fingerprint corresponding to the specified user's private API Key
        """
        return pulumi.get(self, "fingerprint")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        The Kubernetes version that will be used for your master *and* worker nodes e.g. v1.19.7
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="nodeImage")
    def node_image(self) -> builtins.str:
        """
        The OS for the node image
        """
        return pulumi.get(self, "node_image")

    @property
    @pulumi.getter(name="nodeShape")
    def node_shape(self) -> builtins.str:
        """
        The shape of the node (determines number of CPUs and  amount of memory on each node)
        """
        return pulumi.get(self, "node_shape")

    @property
    @pulumi.getter(name="privateKeyContents")
    def private_key_contents(self) -> builtins.str:
        """
        The private API key file contents for the specified user, in PEM format
        """
        return pulumi.get(self, "private_key_contents")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        """
        The availability domain within the region to host the OKE cluster
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenancyId")
    def tenancy_id(self) -> builtins.str:
        """
        The OCID of the tenancy in which to create resources
        """
        return pulumi.get(self, "tenancy_id")

    @property
    @pulumi.getter(name="userOcid")
    def user_ocid(self) -> builtins.str:
        """
        The OCID of a user who has access to the tenancy/compartment
        """
        return pulumi.get(self, "user_ocid")

    @property
    @pulumi.getter(name="customBootVolumeSize")
    def custom_boot_volume_size(self) -> Optional[builtins.int]:
        """
        An optional custom boot volume size (in GB) for the nodes
        """
        return pulumi.get(self, "custom_boot_volume_size")

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[builtins.bool]:
        """
        Enable the kubernetes dashboard
        """
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @property
    @pulumi.getter(name="enablePrivateControlPlane")
    def enable_private_control_plane(self) -> Optional[builtins.bool]:
        """
        Whether Kubernetes API endpoint is a private IP only accessible from within the VCN
        """
        return pulumi.get(self, "enable_private_control_plane")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[builtins.bool]:
        """
        Whether worker nodes are deployed into a new private subnet
        """
        return pulumi.get(self, "enable_private_nodes")

    @property
    @pulumi.getter(name="flexOcpus")
    def flex_ocpus(self) -> Optional[builtins.int]:
        """
        Optional number of OCPUs for nodes (requires flexible node_shape)
        """
        return pulumi.get(self, "flex_ocpus")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[builtins.str]:
        """
        Optional specify the OCID of the KMS Vault master key
        """
        return pulumi.get(self, "kms_key_id")

    @property
    @pulumi.getter(name="limitNodeCount")
    def limit_node_count(self) -> Optional[builtins.int]:
        """
        Optional limit on the total number of nodes in the pool
        """
        return pulumi.get(self, "limit_node_count")

    @property
    @pulumi.getter(name="loadBalancerSubnetName1")
    def load_balancer_subnet_name1(self) -> Optional[builtins.str]:
        """
        The name of the first existing subnet to use for Kubernetes services / LB
        """
        return pulumi.get(self, "load_balancer_subnet_name1")

    @property
    @pulumi.getter(name="loadBalancerSubnetName2")
    def load_balancer_subnet_name2(self) -> Optional[builtins.str]:
        """
        The (optional) name of a second existing subnet to use for Kubernetes services / LB
        """
        return pulumi.get(self, "load_balancer_subnet_name2")

    @property
    @pulumi.getter(name="nodePoolDnsDomainName")
    def node_pool_dns_domain_name(self) -> Optional[builtins.str]:
        """
        Optional name for DNS domain of node pool subnet
        """
        return pulumi.get(self, "node_pool_dns_domain_name")

    @property
    @pulumi.getter(name="nodePoolSubnetName")
    def node_pool_subnet_name(self) -> Optional[builtins.str]:
        """
        Optional name for node pool subnet
        """
        return pulumi.get(self, "node_pool_subnet_name")

    @property
    @pulumi.getter(name="nodePublicKeyContents")
    def node_public_key_contents(self) -> Optional[builtins.str]:
        """
        The contents of the SSH public key file to use for the nodes
        """
        return pulumi.get(self, "node_public_key_contents")

    @property
    @pulumi.getter(name="podCidr")
    def pod_cidr(self) -> Optional[builtins.str]:
        """
        Optional specify the pod CIDR, defaults to 10.244.0.0/16
        """
        return pulumi.get(self, "pod_cidr")

    @property
    @pulumi.getter(name="privateKeyPassphrase")
    def private_key_passphrase(self) -> Optional[builtins.str]:
        """
        The passphrase of the private key for the OKE cluster
        """
        return pulumi.get(self, "private_key_passphrase")

    @property
    @pulumi.getter(name="quantityOfNodeSubnets")
    def quantity_of_node_subnets(self) -> Optional[builtins.int]:
        """
        Number of node subnets (defaults to creating 1 regional subnet)
        """
        return pulumi.get(self, "quantity_of_node_subnets")

    @property
    @pulumi.getter(name="quantityPerSubnet")
    def quantity_per_subnet(self) -> Optional[builtins.int]:
        """
        Number of worker nodes in each subnet / availability domain
        """
        return pulumi.get(self, "quantity_per_subnet")

    @property
    @pulumi.getter(name="serviceCidr")
    def service_cidr(self) -> Optional[builtins.str]:
        """
        Optional specify the service CIDR, defaults to 10.96.0.0/16
        """
        return pulumi.get(self, "service_cidr")

    @property
    @pulumi.getter(name="serviceDnsDomainName")
    def service_dns_domain_name(self) -> Optional[builtins.str]:
        """
        Optional name for DNS domain of service subnet
        """
        return pulumi.get(self, "service_dns_domain_name")

    @property
    @pulumi.getter(name="skipVcnDelete")
    def skip_vcn_delete(self) -> Optional[builtins.bool]:
        """
        Whether to skip deleting VCN
        """
        return pulumi.get(self, "skip_vcn_delete")

    @property
    @pulumi.getter(name="vcnCompartmentId")
    def vcn_compartment_id(self) -> Optional[builtins.str]:
        """
        The OCID of the compartment (if different from compartment_id) in which to find the pre-existing virtual network set with vcn_name.
        """
        return pulumi.get(self, "vcn_compartment_id")

    @property
    @pulumi.getter(name="vcnName")
    def vcn_name(self) -> Optional[builtins.str]:
        """
        The optional name of an existing virtual network to use for the cluster creation. A new VCN will be created if not specified.
        """
        return pulumi.get(self, "vcn_name")

    @property
    @pulumi.getter(name="workerNodeIngressCidr")
    def worker_node_ingress_cidr(self) -> Optional[builtins.str]:
        """
        Additional CIDR from which to allow ingress to worker nodes
        """
        return pulumi.get(self, "worker_node_ingress_cidr")


@pulumi.output_type
class GetClusterRke2ConfigResult(dict):
    def __init__(__self__, *,
                 upgrade_strategy: 'outputs.GetClusterRke2ConfigUpgradeStrategyResult',
                 version: builtins.str):
        """
        :param 'GetClusterRke2ConfigUpgradeStrategyArgs' upgrade_strategy: The RKE2 upgrade strategy
        :param builtins.str version: The RKE2 kubernetes version
        """
        pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterRke2ConfigUpgradeStrategyResult':
        """
        The RKE2 upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter
    def version(self) -> builtins.str:
        """
        The RKE2 kubernetes version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterRke2ConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_server_nodes: Optional[builtins.bool] = None,
                 drain_worker_nodes: Optional[builtins.bool] = None,
                 server_concurrency: Optional[builtins.int] = None,
                 worker_concurrency: Optional[builtins.int] = None):
        """
        :param builtins.bool drain_server_nodes: Drain server nodes
        :param builtins.bool drain_worker_nodes: Drain worker nodes
        :param builtins.int server_concurrency: Server concurrency
        :param builtins.int worker_concurrency: Worker concurrency
        """
        if drain_server_nodes is not None:
            pulumi.set(__self__, "drain_server_nodes", drain_server_nodes)
        if drain_worker_nodes is not None:
            pulumi.set(__self__, "drain_worker_nodes", drain_worker_nodes)
        if server_concurrency is not None:
            pulumi.set(__self__, "server_concurrency", server_concurrency)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)

    @property
    @pulumi.getter(name="drainServerNodes")
    def drain_server_nodes(self) -> Optional[builtins.bool]:
        """
        Drain server nodes
        """
        return pulumi.get(self, "drain_server_nodes")

    @property
    @pulumi.getter(name="drainWorkerNodes")
    def drain_worker_nodes(self) -> Optional[builtins.bool]:
        """
        Drain worker nodes
        """
        return pulumi.get(self, "drain_worker_nodes")

    @property
    @pulumi.getter(name="serverConcurrency")
    def server_concurrency(self) -> Optional[builtins.int]:
        """
        Server concurrency
        """
        return pulumi.get(self, "server_concurrency")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[builtins.int]:
        """
        Worker concurrency
        """
        return pulumi.get(self, "worker_concurrency")


@pulumi.output_type
class GetClusterRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: builtins.int,
                 authentication: 'outputs.GetClusterRkeConfigAuthenticationResult',
                 authorization: 'outputs.GetClusterRkeConfigAuthorizationResult',
                 bastion_host: 'outputs.GetClusterRkeConfigBastionHostResult',
                 cloud_provider: 'outputs.GetClusterRkeConfigCloudProviderResult',
                 dns: 'outputs.GetClusterRkeConfigDnsResult',
                 ingress: 'outputs.GetClusterRkeConfigIngressResult',
                 kubernetes_version: builtins.str,
                 monitoring: 'outputs.GetClusterRkeConfigMonitoringResult',
                 network: 'outputs.GetClusterRkeConfigNetworkResult',
                 prefix_path: builtins.str,
                 services: 'outputs.GetClusterRkeConfigServicesResult',
                 ssh_cert_path: builtins.str,
                 ssh_key_path: builtins.str,
                 upgrade_strategy: 'outputs.GetClusterRkeConfigUpgradeStrategyResult',
                 win_prefix_path: builtins.str,
                 addons: Optional[builtins.str] = None,
                 addons_includes: Optional[Sequence[builtins.str]] = None,
                 enable_cri_dockerd: Optional[builtins.bool] = None,
                 ignore_docker_version: Optional[builtins.bool] = None,
                 nodes: Optional[Sequence['outputs.GetClusterRkeConfigNodeResult']] = None,
                 private_registries: Optional[Sequence['outputs.GetClusterRkeConfigPrivateRegistryResult']] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None):
        """
        :param builtins.int addon_job_timeout: Optional duration in seconds of addon job.
        :param 'GetClusterRkeConfigAuthenticationArgs' authentication: Kubernetes cluster authentication
        :param 'GetClusterRkeConfigAuthorizationArgs' authorization: Kubernetes cluster authorization
        :param 'GetClusterRkeConfigBastionHostArgs' bastion_host: RKE bastion host
        :param 'GetClusterRkeConfigIngressArgs' ingress: Kubernetes ingress configuration
        :param builtins.str kubernetes_version: Optional kubernetes version to deploy
        :param 'GetClusterRkeConfigMonitoringArgs' monitoring: Kubernetes cluster monitoring
        :param 'GetClusterRkeConfigNetworkArgs' network: Kubernetes cluster networking
        :param builtins.str prefix_path: Optional prefix to customize kubernetes path
        :param 'GetClusterRkeConfigServicesArgs' services: Kubernetes cluster services
        :param builtins.str ssh_cert_path: Optional cluster level SSH certificate path
        :param builtins.str ssh_key_path: Optional cluster level SSH private key path
        :param 'GetClusterRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param builtins.str win_prefix_path: Optional prefix to customize kubernetes path for windows nodes
        :param builtins.str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[builtins.str] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param builtins.bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param builtins.bool ignore_docker_version: Optional ignore docker version on nodes
        :param Sequence['GetClusterRkeConfigNodeArgs'] nodes: Optional RKE cluster nodes
        :param Sequence['GetClusterRkeConfigPrivateRegistryArgs'] private_registries: Optional private registries for docker images
        :param builtins.bool ssh_agent_auth: Optional use ssh agent auth
        """
        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) -> builtins.int:
        """
        Optional duration in seconds of addon job.
        """
        return pulumi.get(self, "addon_job_timeout")

    @property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetClusterRkeConfigAuthenticationResult':
        """
        Kubernetes cluster authentication
        """
        return pulumi.get(self, "authentication")

    @property
    @pulumi.getter
    def authorization(self) -> 'outputs.GetClusterRkeConfigAuthorizationResult':
        """
        Kubernetes cluster authorization
        """
        return pulumi.get(self, "authorization")

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> 'outputs.GetClusterRkeConfigBastionHostResult':
        """
        RKE bastion host
        """
        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':
        """
        Kubernetes ingress configuration
        """
        return pulumi.get(self, "ingress")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        Optional kubernetes version to deploy
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def monitoring(self) -> 'outputs.GetClusterRkeConfigMonitoringResult':
        """
        Kubernetes cluster monitoring
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterRkeConfigNetworkResult':
        """
        Kubernetes cluster networking
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> builtins.str:
        """
        Optional prefix to customize kubernetes path
        """
        return pulumi.get(self, "prefix_path")

    @property
    @pulumi.getter
    def services(self) -> 'outputs.GetClusterRkeConfigServicesResult':
        """
        Kubernetes cluster services
        """
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> builtins.str:
        """
        Optional cluster level SSH certificate path
        """
        return pulumi.get(self, "ssh_cert_path")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> builtins.str:
        """
        Optional cluster level SSH private key path
        """
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterRkeConfigUpgradeStrategyResult':
        """
        RKE upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter(name="winPrefixPath")
    def win_prefix_path(self) -> builtins.str:
        """
        Optional prefix to customize kubernetes path for windows nodes
        """
        return pulumi.get(self, "win_prefix_path")

    @property
    @pulumi.getter
    def addons(self) -> Optional[builtins.str]:
        """
        Optional addons descripton to deploy on rke cluster.
        """
        return pulumi.get(self, "addons")

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[Sequence[builtins.str]]:
        """
        Optional addons yaml manisfest to deploy on rke cluster.
        """
        return pulumi.get(self, "addons_includes")

    @property
    @pulumi.getter(name="enableCriDockerd")
    def enable_cri_dockerd(self) -> Optional[builtins.bool]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[builtins.bool]:
        """
        Optional ignore docker version on nodes
        """
        return pulumi.get(self, "ignore_docker_version")

    @property
    @pulumi.getter
    def nodes(self) -> Optional[Sequence['outputs.GetClusterRkeConfigNodeResult']]:
        """
        Optional RKE cluster nodes
        """
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[Sequence['outputs.GetClusterRkeConfigPrivateRegistryResult']]:
        """
        Optional private registries for docker images
        """
        return pulumi.get(self, "private_registries")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.bool]:
        """
        Optional use ssh agent auth
        """
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigAuthenticationResult(dict):
    def __init__(__self__, *,
                 sans: Sequence[builtins.str],
                 strategy: builtins.str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "sans")

    @property
    @pulumi.getter
    def strategy(self) -> builtins.str:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigAuthorizationResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, builtins.str],
                 mode: Optional[builtins.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, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def mode(self) -> Optional[builtins.str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetClusterRkeConfigBastionHostResult(dict):
    def __init__(__self__, *,
                 address: builtins.str,
                 ssh_key: builtins.str,
                 ssh_key_path: builtins.str,
                 user: builtins.str,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> builtins.str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> builtins.str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderResult(dict):
    def __init__(__self__, *,
                 custom_cloud_provider: builtins.str,
                 aws_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 name: Optional[builtins.str] = None,
                 openstack_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult'] = None,
                 vsphere_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderResult'] = None):
        """
        :param builtins.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) -> builtins.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[builtins.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: builtins.str,
                 kubernetes_cluster_id: builtins.str,
                 kubernetes_cluster_tag: builtins.str,
                 role_arn: builtins.str,
                 route_table_id: builtins.str,
                 subnet_id: builtins.str,
                 vpc: builtins.str,
                 zone: builtins.str,
                 disable_security_group_ingress: Optional[builtins.bool] = None,
                 disable_strict_zone_check: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> builtins.str:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> builtins.str:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> builtins.str:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> builtins.str:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> builtins.str:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> builtins.str:
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "disable_strict_zone_check")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult(dict):
    def __init__(__self__, *,
                 region: builtins.str,
                 service: builtins.str,
                 signing_method: builtins.str,
                 signing_name: builtins.str,
                 signing_region: builtins.str,
                 url: builtins.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) -> builtins.str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def service(self) -> builtins.str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> builtins.str:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> builtins.str:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> builtins.str:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> builtins.str:
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAzureCloudProviderResult(dict):
    def __init__(__self__, *,
                 aad_client_cert_password: builtins.str,
                 aad_client_cert_path: builtins.str,
                 aad_client_id: builtins.str,
                 aad_client_secret: builtins.str,
                 cloud: builtins.str,
                 cloud_provider_backoff: builtins.bool,
                 cloud_provider_backoff_duration: builtins.int,
                 cloud_provider_backoff_exponent: builtins.int,
                 cloud_provider_backoff_jitter: builtins.int,
                 cloud_provider_backoff_retries: builtins.int,
                 cloud_provider_rate_limit: builtins.bool,
                 cloud_provider_rate_limit_bucket: builtins.int,
                 cloud_provider_rate_limit_qps: builtins.int,
                 location: builtins.str,
                 maximum_load_balancer_rule_count: builtins.int,
                 primary_availability_set_name: builtins.str,
                 primary_scale_set_name: builtins.str,
                 resource_group: builtins.str,
                 route_table_name: builtins.str,
                 security_group_name: builtins.str,
                 subnet_name: builtins.str,
                 subscription_id: builtins.str,
                 tenant_id: builtins.str,
                 use_instance_metadata: builtins.bool,
                 use_managed_identity_extension: builtins.bool,
                 vm_type: builtins.str,
                 vnet_name: builtins.str,
                 vnet_resource_group: builtins.str,
                 load_balancer_sku: Optional[builtins.str] = None):
        """
        :param builtins.str load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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) -> builtins.str:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> builtins.str:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> builtins.str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> builtins.str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter
    def cloud(self) -> builtins.str:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> builtins.bool:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> builtins.bool:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter
    def location(self) -> builtins.str:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> builtins.int:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> builtins.str:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> builtins.str:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> builtins.str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> builtins.str:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> builtins.str:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> builtins.str:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> builtins.str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> builtins.str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> builtins.bool:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> builtins.bool:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> builtins.str:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> builtins.str:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> builtins.str:
        return pulumi.get(self, "vnet_resource_group")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[builtins.str]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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: builtins.str,
                 ignore_volume_az: builtins.bool,
                 trust_device_path: builtins.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) -> builtins.str:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> builtins.bool:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> builtins.bool:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 auth_url: builtins.str,
                 ca_file: builtins.str,
                 domain_id: builtins.str,
                 domain_name: builtins.str,
                 password: builtins.str,
                 region: builtins.str,
                 tenant_id: builtins.str,
                 tenant_name: builtins.str,
                 trust_id: builtins.str,
                 username: builtins.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) -> builtins.str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> builtins.str:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> builtins.str:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> builtins.str:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> builtins.str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> builtins.str:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> builtins.str:
        return pulumi.get(self, "trust_id")

    @property
    @pulumi.getter
    def username(self) -> builtins.str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult(dict):
    def __init__(__self__, *,
                 create_monitor: builtins.bool,
                 floating_network_id: builtins.str,
                 lb_method: builtins.str,
                 lb_provider: builtins.str,
                 lb_version: builtins.str,
                 manage_security_groups: builtins.bool,
                 subnet_id: builtins.str,
                 use_octavia: builtins.bool,
                 monitor_delay: Optional[builtins.str] = None,
                 monitor_max_retries: Optional[builtins.int] = None,
                 monitor_timeout: Optional[builtins.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) -> builtins.bool:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> builtins.str:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> builtins.str:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> builtins.str:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> builtins.str:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> builtins.bool:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> builtins.bool:
        return pulumi.get(self, "use_octavia")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[builtins.str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[builtins.int]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[builtins.str]:
        return pulumi.get(self, "monitor_timeout")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult(dict):
    def __init__(__self__, *,
                 request_timeout: builtins.int,
                 search_order: builtins.str):
        pulumi.set(__self__, "request_timeout", request_timeout)
        pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> builtins.int:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> builtins.str:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult(dict):
    def __init__(__self__, *,
                 router_id: builtins.str):
        pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> builtins.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: builtins.str):
        pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> builtins.str:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 datacenters: builtins.str,
                 insecure_flag: builtins.bool,
                 password: builtins.str,
                 port: builtins.str,
                 soap_roundtrip_count: builtins.int,
                 user: builtins.str,
                 graceful_shutdown_timeout: Optional[builtins.str] = None):
        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)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)

    @property
    @pulumi.getter
    def datacenters(self) -> builtins.str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> builtins.bool:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> builtins.int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[builtins.str]:
        return pulumi.get(self, "graceful_shutdown_timeout")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult(dict):
    def __init__(__self__, *,
                 public_network: builtins.str):
        pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> builtins.str:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult(dict):
    def __init__(__self__, *,
                 datacenters: builtins.str,
                 name: builtins.str,
                 password: builtins.str,
                 port: builtins.str,
                 soap_roundtrip_count: builtins.int,
                 user: builtins.str):
        """
        :param builtins.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) -> builtins.str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> builtins.int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult(dict):
    def __init__(__self__, *,
                 datacenter: builtins.str,
                 default_datastore: builtins.str,
                 folder: builtins.str,
                 resourcepool_path: builtins.str,
                 server: builtins.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) -> builtins.str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> builtins.str:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter
    def folder(self) -> builtins.str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> builtins.str:
        return pulumi.get(self, "resourcepool_path")

    @property
    @pulumi.getter
    def server(self) -> builtins.str:
        return pulumi.get(self, "server")


@pulumi.output_type
class GetClusterRkeConfigDnsResult(dict):
    def __init__(__self__, *,
                 node_selector: Mapping[str, builtins.str],
                 options: Mapping[str, builtins.str],
                 reverse_cidrs: Sequence[builtins.str],
                 upstream_nameservers: Sequence[builtins.str],
                 linear_autoscaler_params: Optional['outputs.GetClusterRkeConfigDnsLinearAutoscalerParamsResult'] = None,
                 nodelocal: Optional['outputs.GetClusterRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[builtins.str] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigDnsTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyResult'] = None):
        """
        :param 'GetClusterRkeConfigDnsLinearAutoscalerParamsArgs' linear_autoscaler_params: Linear Autoscaler Params
        :param 'GetClusterRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns
        :param Sequence['GetClusterRkeConfigDnsTolerationArgs'] tolerations: DNS service tolerations
        :param 'GetClusterRkeConfigDnsUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        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, builtins.str]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "upstream_nameservers")

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.GetClusterRkeConfigDnsLinearAutoscalerParamsResult']:
        """
        Linear Autoscaler Params
        """
        return pulumi.get(self, "linear_autoscaler_params")

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional['outputs.GetClusterRkeConfigDnsNodelocalResult']:
        """
        Nodelocal dns
        """
        return pulumi.get(self, "nodelocal")

    @property
    @pulumi.getter
    def provider(self) -> Optional[builtins.str]:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigDnsTolerationResult']]:
        """
        DNS service tolerations
        """
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyResult']:
        """
        Update deployment strategy
        """
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterRkeConfigDnsLinearAutoscalerParamsResult(dict):
    def __init__(__self__, *,
                 cores_per_replica: Optional[builtins.float] = None,
                 max: Optional[builtins.int] = None,
                 min: Optional[builtins.int] = None,
                 nodes_per_replica: Optional[builtins.float] = None,
                 prevent_single_point_failure: Optional[builtins.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[builtins.float]:
        return pulumi.get(self, "cores_per_replica")

    @property
    @pulumi.getter
    def max(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional[builtins.int]:
        return pulumi.get(self, "min")

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[builtins.float]:
        return pulumi.get(self, "nodes_per_replica")

    @property
    @pulumi.getter(name="preventSinglePointFailure")
    def prevent_single_point_failure(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "prevent_single_point_failure")


@pulumi.output_type
class GetClusterRkeConfigDnsNodelocalResult(dict):
    def __init__(__self__, *,
                 ip_address: Optional[builtins.str] = None,
                 node_selector: Optional[Mapping[str, builtins.str]] = None):
        """
        :param Mapping[str, builtins.str] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[builtins.str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class GetClusterRkeConfigDnsTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigDnsUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[builtins.str] = None):
        """
        :param 'GetClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 http_port: builtins.int,
                 https_port: builtins.int,
                 network_mode: builtins.str,
                 node_selector: Mapping[str, builtins.str],
                 options: Mapping[str, builtins.str],
                 provider: builtins.str,
                 default_backend: Optional[builtins.bool] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigIngressTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyResult'] = None):
        """
        :param Sequence['GetClusterRkeConfigIngressTolerationArgs'] tolerations: Ingress add-on tolerations
        :param 'GetClusterRkeConfigIngressUpdateStrategyArgs' update_strategy: Update daemon set strategy
        """
        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) -> builtins.str:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> builtins.int:
        return pulumi.get(self, "http_port")

    @property
    @pulumi.getter(name="httpsPort")
    def https_port(self) -> builtins.int:
        return pulumi.get(self, "https_port")

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> builtins.str:
        return pulumi.get(self, "network_mode")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> builtins.str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter(name="defaultBackend")
    def default_backend(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "default_backend")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigIngressTolerationResult']]:
        """
        Ingress add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyResult']:
        """
        Update daemon set strategy
        """
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterRkeConfigIngressTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigIngressUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[builtins.str] = None):
        """
        :param 'GetClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, builtins.str],
                 provider: builtins.str,
                 replicas: builtins.int,
                 node_selector: Optional[Mapping[str, builtins.str]] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigMonitoringTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyResult'] = None):
        """
        :param Sequence['GetClusterRkeConfigMonitoringTolerationArgs'] tolerations: Monitoring add-on tolerations
        :param 'GetClusterRkeConfigMonitoringUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        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, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> builtins.str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> builtins.int:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigMonitoringTolerationResult']]:
        """
        Monitoring add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyResult']:
        """
        Update deployment strategy
        """
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterRkeConfigMonitoringTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigMonitoringUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[builtins.str] = None):
        """
        :param 'GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigNetworkResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, builtins.str],
                 plugin: builtins.str,
                 aci_network_provider: Optional['outputs.GetClusterRkeConfigNetworkAciNetworkProviderResult'] = None,
                 calico_network_provider: Optional['outputs.GetClusterRkeConfigNetworkCalicoNetworkProviderResult'] = None,
                 canal_network_provider: Optional['outputs.GetClusterRkeConfigNetworkCanalNetworkProviderResult'] = None,
                 flannel_network_provider: Optional['outputs.GetClusterRkeConfigNetworkFlannelNetworkProviderResult'] = None,
                 mtu: Optional[builtins.int] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigNetworkTolerationResult']] = None,
                 weave_network_provider: Optional['outputs.GetClusterRkeConfigNetworkWeaveNetworkProviderResult'] = None):
        """
        :param Sequence['GetClusterRkeConfigNetworkTolerationArgs'] tolerations: Network add-on tolerations
        """
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "plugin", plugin)
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if 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, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> builtins.str:
        return pulumi.get(self, "plugin")

    @property
    @pulumi.getter(name="aciNetworkProvider")
    def aci_network_provider(self) -> Optional['outputs.GetClusterRkeConfigNetworkAciNetworkProviderResult']:
        return pulumi.get(self, "aci_network_provider")

    @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[builtins.int]:
        return pulumi.get(self, "mtu")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigNetworkTolerationResult']]:
        """
        Network add-on tolerations
        """
        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 GetClusterRkeConfigNetworkAciNetworkProviderResult(dict):
    def __init__(__self__, *,
                 aep: builtins.str,
                 apic_hosts: Sequence[builtins.str],
                 apic_user_crt: builtins.str,
                 apic_user_key: builtins.str,
                 apic_user_name: builtins.str,
                 encap_type: builtins.str,
                 extern_dynamic: builtins.str,
                 extern_static: builtins.str,
                 kube_api_vlan: builtins.str,
                 l3out: builtins.str,
                 l3out_external_networks: Sequence[builtins.str],
                 mcast_range_end: builtins.str,
                 mcast_range_start: builtins.str,
                 node_subnet: builtins.str,
                 node_svc_subnet: builtins.str,
                 service_vlan: builtins.str,
                 system_id: builtins.str,
                 token: builtins.str,
                 vrf_name: builtins.str,
                 vrf_tenant: builtins.str,
                 apic_refresh_ticker_adjust: Optional[builtins.str] = None,
                 apic_refresh_time: Optional[builtins.str] = None,
                 apic_subscription_delay: Optional[builtins.str] = None,
                 capic: Optional[builtins.str] = None,
                 controller_log_level: Optional[builtins.str] = None,
                 disable_periodic_snat_global_info_sync: Optional[builtins.str] = None,
                 disable_wait_for_network: Optional[builtins.str] = None,
                 drop_log_enable: Optional[builtins.str] = None,
                 duration_wait_for_network: Optional[builtins.str] = None,
                 enable_endpoint_slice: Optional[builtins.str] = None,
                 ep_registry: Optional[builtins.str] = None,
                 gbp_pod_subnet: Optional[builtins.str] = None,
                 host_agent_log_level: Optional[builtins.str] = None,
                 image_pull_policy: Optional[builtins.str] = None,
                 image_pull_secret: Optional[builtins.str] = None,
                 infra_vlan: Optional[builtins.str] = None,
                 install_istio: Optional[builtins.str] = None,
                 istio_profile: Optional[builtins.str] = None,
                 kafka_brokers: Optional[Sequence[builtins.str]] = None,
                 kafka_client_crt: Optional[builtins.str] = None,
                 kafka_client_key: Optional[builtins.str] = None,
                 max_nodes_svc_graph: Optional[builtins.str] = None,
                 mtu_head_room: Optional[builtins.str] = None,
                 multus_disable: Optional[builtins.str] = None,
                 no_priority_class: Optional[builtins.str] = None,
                 node_pod_if_enable: Optional[builtins.str] = None,
                 opflex_client_ssl: Optional[builtins.str] = None,
                 opflex_device_delete_timeout: Optional[builtins.str] = None,
                 opflex_log_level: Optional[builtins.str] = None,
                 opflex_mode: Optional[builtins.str] = None,
                 opflex_server_port: Optional[builtins.str] = None,
                 overlay_vrf_name: Optional[builtins.str] = None,
                 ovs_memory_limit: Optional[builtins.str] = None,
                 pbr_tracking_non_snat: Optional[builtins.str] = None,
                 pod_subnet_chunk_size: Optional[builtins.str] = None,
                 run_gbp_container: Optional[builtins.str] = None,
                 run_opflex_server_container: Optional[builtins.str] = None,
                 service_monitor_interval: Optional[builtins.str] = None,
                 snat_contract_scope: Optional[builtins.str] = None,
                 snat_namespace: Optional[builtins.str] = None,
                 snat_port_range_end: Optional[builtins.str] = None,
                 snat_port_range_start: Optional[builtins.str] = None,
                 snat_ports_per_node: Optional[builtins.str] = None,
                 sriov_enable: Optional[builtins.str] = None,
                 subnet_domain_name: Optional[builtins.str] = None,
                 tenant: Optional[builtins.str] = None,
                 use_aci_anywhere_crd: Optional[builtins.str] = None,
                 use_aci_cni_priority_class: Optional[builtins.str] = None,
                 use_cluster_role: Optional[builtins.str] = None,
                 use_host_netns_volume: Optional[builtins.str] = None,
                 use_opflex_server_volume: Optional[builtins.str] = None,
                 use_privileged_container: Optional[builtins.str] = None,
                 vmm_controller: Optional[builtins.str] = None,
                 vmm_domain: Optional[builtins.str] = None):
        pulumi.set(__self__, "aep", aep)
        pulumi.set(__self__, "apic_hosts", apic_hosts)
        pulumi.set(__self__, "apic_user_crt", apic_user_crt)
        pulumi.set(__self__, "apic_user_key", apic_user_key)
        pulumi.set(__self__, "apic_user_name", apic_user_name)
        pulumi.set(__self__, "encap_type", encap_type)
        pulumi.set(__self__, "extern_dynamic", extern_dynamic)
        pulumi.set(__self__, "extern_static", extern_static)
        pulumi.set(__self__, "kube_api_vlan", kube_api_vlan)
        pulumi.set(__self__, "l3out", l3out)
        pulumi.set(__self__, "l3out_external_networks", l3out_external_networks)
        pulumi.set(__self__, "mcast_range_end", mcast_range_end)
        pulumi.set(__self__, "mcast_range_start", mcast_range_start)
        pulumi.set(__self__, "node_subnet", node_subnet)
        pulumi.set(__self__, "node_svc_subnet", node_svc_subnet)
        pulumi.set(__self__, "service_vlan", service_vlan)
        pulumi.set(__self__, "system_id", system_id)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "vrf_name", vrf_name)
        pulumi.set(__self__, "vrf_tenant", vrf_tenant)
        if apic_refresh_ticker_adjust is not None:
            pulumi.set(__self__, "apic_refresh_ticker_adjust", apic_refresh_ticker_adjust)
        if apic_refresh_time is not None:
            pulumi.set(__self__, "apic_refresh_time", apic_refresh_time)
        if apic_subscription_delay is not None:
            pulumi.set(__self__, "apic_subscription_delay", apic_subscription_delay)
        if capic is not None:
            pulumi.set(__self__, "capic", capic)
        if controller_log_level is not None:
            pulumi.set(__self__, "controller_log_level", controller_log_level)
        if disable_periodic_snat_global_info_sync is not None:
            pulumi.set(__self__, "disable_periodic_snat_global_info_sync", disable_periodic_snat_global_info_sync)
        if disable_wait_for_network is not None:
            pulumi.set(__self__, "disable_wait_for_network", disable_wait_for_network)
        if drop_log_enable is not None:
            pulumi.set(__self__, "drop_log_enable", drop_log_enable)
        if duration_wait_for_network is not None:
            pulumi.set(__self__, "duration_wait_for_network", duration_wait_for_network)
        if enable_endpoint_slice is not None:
            pulumi.set(__self__, "enable_endpoint_slice", enable_endpoint_slice)
        if ep_registry is not None:
            pulumi.set(__self__, "ep_registry", ep_registry)
        if gbp_pod_subnet is not None:
            pulumi.set(__self__, "gbp_pod_subnet", gbp_pod_subnet)
        if host_agent_log_level is not None:
            pulumi.set(__self__, "host_agent_log_level", host_agent_log_level)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if infra_vlan is not None:
            pulumi.set(__self__, "infra_vlan", infra_vlan)
        if install_istio is not None:
            pulumi.set(__self__, "install_istio", install_istio)
        if istio_profile is not None:
            pulumi.set(__self__, "istio_profile", istio_profile)
        if kafka_brokers is not None:
            pulumi.set(__self__, "kafka_brokers", kafka_brokers)
        if kafka_client_crt is not None:
            pulumi.set(__self__, "kafka_client_crt", kafka_client_crt)
        if kafka_client_key is not None:
            pulumi.set(__self__, "kafka_client_key", kafka_client_key)
        if max_nodes_svc_graph is not None:
            pulumi.set(__self__, "max_nodes_svc_graph", max_nodes_svc_graph)
        if mtu_head_room is not None:
            pulumi.set(__self__, "mtu_head_room", mtu_head_room)
        if multus_disable is not None:
            pulumi.set(__self__, "multus_disable", multus_disable)
        if no_priority_class is not None:
            pulumi.set(__self__, "no_priority_class", no_priority_class)
        if node_pod_if_enable is not None:
            pulumi.set(__self__, "node_pod_if_enable", node_pod_if_enable)
        if opflex_client_ssl is not None:
            pulumi.set(__self__, "opflex_client_ssl", opflex_client_ssl)
        if opflex_device_delete_timeout is not None:
            pulumi.set(__self__, "opflex_device_delete_timeout", opflex_device_delete_timeout)
        if opflex_log_level is not None:
            pulumi.set(__self__, "opflex_log_level", opflex_log_level)
        if opflex_mode is not None:
            pulumi.set(__self__, "opflex_mode", opflex_mode)
        if opflex_server_port is not None:
            pulumi.set(__self__, "opflex_server_port", opflex_server_port)
        if overlay_vrf_name is not None:
            pulumi.set(__self__, "overlay_vrf_name", overlay_vrf_name)
        if ovs_memory_limit is not None:
            pulumi.set(__self__, "ovs_memory_limit", ovs_memory_limit)
        if pbr_tracking_non_snat is not None:
            pulumi.set(__self__, "pbr_tracking_non_snat", pbr_tracking_non_snat)
        if pod_subnet_chunk_size is not None:
            pulumi.set(__self__, "pod_subnet_chunk_size", pod_subnet_chunk_size)
        if run_gbp_container is not None:
            pulumi.set(__self__, "run_gbp_container", run_gbp_container)
        if run_opflex_server_container is not None:
            pulumi.set(__self__, "run_opflex_server_container", run_opflex_server_container)
        if service_monitor_interval is not None:
            pulumi.set(__self__, "service_monitor_interval", service_monitor_interval)
        if snat_contract_scope is not None:
            pulumi.set(__self__, "snat_contract_scope", snat_contract_scope)
        if snat_namespace is not None:
            pulumi.set(__self__, "snat_namespace", snat_namespace)
        if snat_port_range_end is not None:
            pulumi.set(__self__, "snat_port_range_end", snat_port_range_end)
        if snat_port_range_start is not None:
            pulumi.set(__self__, "snat_port_range_start", snat_port_range_start)
        if snat_ports_per_node is not None:
            pulumi.set(__self__, "snat_ports_per_node", snat_ports_per_node)
        if sriov_enable is not None:
            pulumi.set(__self__, "sriov_enable", sriov_enable)
        if subnet_domain_name is not None:
            pulumi.set(__self__, "subnet_domain_name", subnet_domain_name)
        if tenant is not None:
            pulumi.set(__self__, "tenant", tenant)
        if use_aci_anywhere_crd is not None:
            pulumi.set(__self__, "use_aci_anywhere_crd", use_aci_anywhere_crd)
        if use_aci_cni_priority_class is not None:
            pulumi.set(__self__, "use_aci_cni_priority_class", use_aci_cni_priority_class)
        if use_cluster_role is not None:
            pulumi.set(__self__, "use_cluster_role", use_cluster_role)
        if use_host_netns_volume is not None:
            pulumi.set(__self__, "use_host_netns_volume", use_host_netns_volume)
        if use_opflex_server_volume is not None:
            pulumi.set(__self__, "use_opflex_server_volume", use_opflex_server_volume)
        if use_privileged_container is not None:
            pulumi.set(__self__, "use_privileged_container", use_privileged_container)
        if vmm_controller is not None:
            pulumi.set(__self__, "vmm_controller", vmm_controller)
        if vmm_domain is not None:
            pulumi.set(__self__, "vmm_domain", vmm_domain)

    @property
    @pulumi.getter
    def aep(self) -> builtins.str:
        return pulumi.get(self, "aep")

    @property
    @pulumi.getter(name="apicHosts")
    def apic_hosts(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "apic_hosts")

    @property
    @pulumi.getter(name="apicUserCrt")
    def apic_user_crt(self) -> builtins.str:
        return pulumi.get(self, "apic_user_crt")

    @property
    @pulumi.getter(name="apicUserKey")
    def apic_user_key(self) -> builtins.str:
        return pulumi.get(self, "apic_user_key")

    @property
    @pulumi.getter(name="apicUserName")
    def apic_user_name(self) -> builtins.str:
        return pulumi.get(self, "apic_user_name")

    @property
    @pulumi.getter(name="encapType")
    def encap_type(self) -> builtins.str:
        return pulumi.get(self, "encap_type")

    @property
    @pulumi.getter(name="externDynamic")
    def extern_dynamic(self) -> builtins.str:
        return pulumi.get(self, "extern_dynamic")

    @property
    @pulumi.getter(name="externStatic")
    def extern_static(self) -> builtins.str:
        return pulumi.get(self, "extern_static")

    @property
    @pulumi.getter(name="kubeApiVlan")
    def kube_api_vlan(self) -> builtins.str:
        return pulumi.get(self, "kube_api_vlan")

    @property
    @pulumi.getter
    def l3out(self) -> builtins.str:
        return pulumi.get(self, "l3out")

    @property
    @pulumi.getter(name="l3outExternalNetworks")
    def l3out_external_networks(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "l3out_external_networks")

    @property
    @pulumi.getter(name="mcastRangeEnd")
    def mcast_range_end(self) -> builtins.str:
        return pulumi.get(self, "mcast_range_end")

    @property
    @pulumi.getter(name="mcastRangeStart")
    def mcast_range_start(self) -> builtins.str:
        return pulumi.get(self, "mcast_range_start")

    @property
    @pulumi.getter(name="nodeSubnet")
    def node_subnet(self) -> builtins.str:
        return pulumi.get(self, "node_subnet")

    @property
    @pulumi.getter(name="nodeSvcSubnet")
    def node_svc_subnet(self) -> builtins.str:
        return pulumi.get(self, "node_svc_subnet")

    @property
    @pulumi.getter(name="serviceVlan")
    def service_vlan(self) -> builtins.str:
        return pulumi.get(self, "service_vlan")

    @property
    @pulumi.getter(name="systemId")
    def system_id(self) -> builtins.str:
        return pulumi.get(self, "system_id")

    @property
    @pulumi.getter
    def token(self) -> builtins.str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="vrfName")
    def vrf_name(self) -> builtins.str:
        return pulumi.get(self, "vrf_name")

    @property
    @pulumi.getter(name="vrfTenant")
    def vrf_tenant(self) -> builtins.str:
        return pulumi.get(self, "vrf_tenant")

    @property
    @pulumi.getter(name="apicRefreshTickerAdjust")
    def apic_refresh_ticker_adjust(self) -> Optional[builtins.str]:
        return pulumi.get(self, "apic_refresh_ticker_adjust")

    @property
    @pulumi.getter(name="apicRefreshTime")
    def apic_refresh_time(self) -> Optional[builtins.str]:
        return pulumi.get(self, "apic_refresh_time")

    @property
    @pulumi.getter(name="apicSubscriptionDelay")
    def apic_subscription_delay(self) -> Optional[builtins.str]:
        return pulumi.get(self, "apic_subscription_delay")

    @property
    @pulumi.getter
    def capic(self) -> Optional[builtins.str]:
        return pulumi.get(self, "capic")

    @property
    @pulumi.getter(name="controllerLogLevel")
    def controller_log_level(self) -> Optional[builtins.str]:
        return pulumi.get(self, "controller_log_level")

    @property
    @pulumi.getter(name="disablePeriodicSnatGlobalInfoSync")
    def disable_periodic_snat_global_info_sync(self) -> Optional[builtins.str]:
        return pulumi.get(self, "disable_periodic_snat_global_info_sync")

    @property
    @pulumi.getter(name="disableWaitForNetwork")
    def disable_wait_for_network(self) -> Optional[builtins.str]:
        return pulumi.get(self, "disable_wait_for_network")

    @property
    @pulumi.getter(name="dropLogEnable")
    def drop_log_enable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "drop_log_enable")

    @property
    @pulumi.getter(name="durationWaitForNetwork")
    def duration_wait_for_network(self) -> Optional[builtins.str]:
        return pulumi.get(self, "duration_wait_for_network")

    @property
    @pulumi.getter(name="enableEndpointSlice")
    def enable_endpoint_slice(self) -> Optional[builtins.str]:
        return pulumi.get(self, "enable_endpoint_slice")

    @property
    @pulumi.getter(name="epRegistry")
    def ep_registry(self) -> Optional[builtins.str]:
        return pulumi.get(self, "ep_registry")

    @property
    @pulumi.getter(name="gbpPodSubnet")
    def gbp_pod_subnet(self) -> Optional[builtins.str]:
        return pulumi.get(self, "gbp_pod_subnet")

    @property
    @pulumi.getter(name="hostAgentLogLevel")
    def host_agent_log_level(self) -> Optional[builtins.str]:
        return pulumi.get(self, "host_agent_log_level")

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[builtins.str]:
        return pulumi.get(self, "image_pull_policy")

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[builtins.str]:
        return pulumi.get(self, "image_pull_secret")

    @property
    @pulumi.getter(name="infraVlan")
    def infra_vlan(self) -> Optional[builtins.str]:
        return pulumi.get(self, "infra_vlan")

    @property
    @pulumi.getter(name="installIstio")
    def install_istio(self) -> Optional[builtins.str]:
        return pulumi.get(self, "install_istio")

    @property
    @pulumi.getter(name="istioProfile")
    def istio_profile(self) -> Optional[builtins.str]:
        return pulumi.get(self, "istio_profile")

    @property
    @pulumi.getter(name="kafkaBrokers")
    def kafka_brokers(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "kafka_brokers")

    @property
    @pulumi.getter(name="kafkaClientCrt")
    def kafka_client_crt(self) -> Optional[builtins.str]:
        return pulumi.get(self, "kafka_client_crt")

    @property
    @pulumi.getter(name="kafkaClientKey")
    def kafka_client_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "kafka_client_key")

    @property
    @pulumi.getter(name="maxNodesSvcGraph")
    def max_nodes_svc_graph(self) -> Optional[builtins.str]:
        return pulumi.get(self, "max_nodes_svc_graph")

    @property
    @pulumi.getter(name="mtuHeadRoom")
    def mtu_head_room(self) -> Optional[builtins.str]:
        return pulumi.get(self, "mtu_head_room")

    @property
    @pulumi.getter(name="multusDisable")
    def multus_disable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "multus_disable")

    @property
    @pulumi.getter(name="noPriorityClass")
    def no_priority_class(self) -> Optional[builtins.str]:
        return pulumi.get(self, "no_priority_class")

    @property
    @pulumi.getter(name="nodePodIfEnable")
    def node_pod_if_enable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "node_pod_if_enable")

    @property
    @pulumi.getter(name="opflexClientSsl")
    def opflex_client_ssl(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_client_ssl")

    @property
    @pulumi.getter(name="opflexDeviceDeleteTimeout")
    def opflex_device_delete_timeout(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_device_delete_timeout")

    @property
    @pulumi.getter(name="opflexLogLevel")
    def opflex_log_level(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_log_level")

    @property
    @pulumi.getter(name="opflexMode")
    def opflex_mode(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_mode")

    @property
    @pulumi.getter(name="opflexServerPort")
    def opflex_server_port(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_server_port")

    @property
    @pulumi.getter(name="overlayVrfName")
    def overlay_vrf_name(self) -> Optional[builtins.str]:
        return pulumi.get(self, "overlay_vrf_name")

    @property
    @pulumi.getter(name="ovsMemoryLimit")
    def ovs_memory_limit(self) -> Optional[builtins.str]:
        return pulumi.get(self, "ovs_memory_limit")

    @property
    @pulumi.getter(name="pbrTrackingNonSnat")
    def pbr_tracking_non_snat(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pbr_tracking_non_snat")

    @property
    @pulumi.getter(name="podSubnetChunkSize")
    def pod_subnet_chunk_size(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pod_subnet_chunk_size")

    @property
    @pulumi.getter(name="runGbpContainer")
    def run_gbp_container(self) -> Optional[builtins.str]:
        return pulumi.get(self, "run_gbp_container")

    @property
    @pulumi.getter(name="runOpflexServerContainer")
    def run_opflex_server_container(self) -> Optional[builtins.str]:
        return pulumi.get(self, "run_opflex_server_container")

    @property
    @pulumi.getter(name="serviceMonitorInterval")
    def service_monitor_interval(self) -> Optional[builtins.str]:
        return pulumi.get(self, "service_monitor_interval")

    @property
    @pulumi.getter(name="snatContractScope")
    def snat_contract_scope(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_contract_scope")

    @property
    @pulumi.getter(name="snatNamespace")
    def snat_namespace(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_namespace")

    @property
    @pulumi.getter(name="snatPortRangeEnd")
    def snat_port_range_end(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_port_range_end")

    @property
    @pulumi.getter(name="snatPortRangeStart")
    def snat_port_range_start(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_port_range_start")

    @property
    @pulumi.getter(name="snatPortsPerNode")
    def snat_ports_per_node(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_ports_per_node")

    @property
    @pulumi.getter(name="sriovEnable")
    def sriov_enable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "sriov_enable")

    @property
    @pulumi.getter(name="subnetDomainName")
    def subnet_domain_name(self) -> Optional[builtins.str]:
        return pulumi.get(self, "subnet_domain_name")

    @property
    @pulumi.getter
    def tenant(self) -> Optional[builtins.str]:
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter(name="useAciAnywhereCrd")
    def use_aci_anywhere_crd(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_aci_anywhere_crd")

    @property
    @pulumi.getter(name="useAciCniPriorityClass")
    def use_aci_cni_priority_class(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_aci_cni_priority_class")

    @property
    @pulumi.getter(name="useClusterRole")
    def use_cluster_role(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_cluster_role")

    @property
    @pulumi.getter(name="useHostNetnsVolume")
    def use_host_netns_volume(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_host_netns_volume")

    @property
    @pulumi.getter(name="useOpflexServerVolume")
    def use_opflex_server_volume(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_opflex_server_volume")

    @property
    @pulumi.getter(name="usePrivilegedContainer")
    def use_privileged_container(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_privileged_container")

    @property
    @pulumi.getter(name="vmmController")
    def vmm_controller(self) -> Optional[builtins.str]:
        return pulumi.get(self, "vmm_controller")

    @property
    @pulumi.getter(name="vmmDomain")
    def vmm_domain(self) -> Optional[builtins.str]:
        return pulumi.get(self, "vmm_domain")


@pulumi.output_type
class GetClusterRkeConfigNetworkCalicoNetworkProviderResult(dict):
    def __init__(__self__, *,
                 cloud_provider: builtins.str):
        pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> builtins.str:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class GetClusterRkeConfigNetworkCanalNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: builtins.str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> builtins.str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterRkeConfigNetworkFlannelNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: builtins.str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> builtins.str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterRkeConfigNetworkTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigNetworkWeaveNetworkProviderResult(dict):
    def __init__(__self__, *,
                 password: builtins.str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")


@pulumi.output_type
class GetClusterRkeConfigNodeResult(dict):
    def __init__(__self__, *,
                 address: builtins.str,
                 docker_socket: builtins.str,
                 roles: Sequence[builtins.str],
                 ssh_key: builtins.str,
                 ssh_key_path: builtins.str,
                 user: builtins.str,
                 hostname_override: Optional[builtins.str] = None,
                 internal_address: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 node_id: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None):
        """
        :param Mapping[str, builtins.str] 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) -> builtins.str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> builtins.str:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> builtins.str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> builtins.str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[builtins.str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[builtins.str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[builtins.str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigPrivateRegistryResult(dict):
    def __init__(__self__, *,
                 url: builtins.str,
                 ecr_credential_plugin: Optional['outputs.GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult'] = None,
                 is_default: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 user: Optional[builtins.str] = None):
        """
        :param 'GetClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs' ecr_credential_plugin: ECR credential plugin config
        """
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> builtins.str:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional['outputs.GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult']:
        """
        ECR credential plugin config
        """
        return pulumi.get(self, "ecr_credential_plugin")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[builtins.str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult(dict):
    def __init__(__self__, *,
                 aws_access_key_id: Optional[builtins.str] = None,
                 aws_secret_access_key: Optional[builtins.str] = None,
                 aws_session_token: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "aws_access_key_id")

    @property
    @pulumi.getter(name="awsSecretAccessKey")
    def aws_secret_access_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "aws_secret_access_key")

    @property
    @pulumi.getter(name="awsSessionToken")
    def aws_session_token(self) -> Optional[builtins.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: builtins.str,
                 cert: builtins.str,
                 creation: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 key: builtins.str,
                 path: builtins.str,
                 retention: builtins.str,
                 snapshot: builtins.bool,
                 external_urls: Optional[Sequence[builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 gid: Optional[builtins.int] = None,
                 uid: Optional[builtins.int] = None):
        """
        :param builtins.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) -> builtins.str:
        """
        (Computed) K8s cluster ca cert (string)
        """
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> builtins.str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> builtins.str:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> builtins.str:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> builtins.bool:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[builtins.int]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def uid(self) -> Optional[builtins.int]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: builtins.int,
                 enabled: Optional[builtins.bool] = None,
                 interval_hours: Optional[builtins.int] = None,
                 retention: Optional[builtins.int] = None,
                 s3_backup_config: Optional['outputs.GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[builtins.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) -> builtins.int:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[builtins.int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: builtins.str,
                 endpoint: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 custom_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> builtins.str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[builtins.str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 service_cluster_ip_range: builtins.str,
                 service_node_port_range: builtins.str,
                 admission_configuration: Optional['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult'] = None,
                 always_pull_images: Optional[builtins.bool] = None,
                 audit_log: Optional['outputs.GetClusterRkeConfigServicesKubeApiAuditLogResult'] = None,
                 event_rate_limit: Optional['outputs.GetClusterRkeConfigServicesKubeApiEventRateLimitResult'] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 secrets_encryption_config: Optional['outputs.GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult'] = None):
        """
        :param 'GetClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs' admission_configuration: Cluster admission configuration
        """
        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 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, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> builtins.str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> builtins.str:
        return pulumi.get(self, "service_node_port_range")

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[builtins.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[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult']:
        return pulumi.get(self, "secrets_encryption_config")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult(dict):
    def __init__(__self__, *,
                 plugins: Sequence['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginResult'],
                 api_version: Optional[builtins.str] = None,
                 kind: Optional[builtins.str] = None):
        """
        :param Sequence['GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs'] plugins: Admission configuration plugins
        :param builtins.str api_version: Admission configuration ApiVersion
        :param builtins.str kind: Admission configuration Kind
        """
        pulumi.set(__self__, "plugins", plugins)
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)

    @property
    @pulumi.getter
    def plugins(self) -> Sequence['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginResult']:
        """
        Admission configuration plugins
        """
        return pulumi.get(self, "plugins")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[builtins.str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[builtins.str]:
        """
        Admission configuration Kind
        """
        return pulumi.get(self, "kind")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginResult(dict):
    def __init__(__self__, *,
                 configuration: builtins.str,
                 name: builtins.str,
                 path: Optional[builtins.str] = None):
        """
        :param builtins.str configuration: Plugin configuration
        :param builtins.str name: The name of the Cluster (string)
        :param builtins.str path: Plugin path
        """
        pulumi.set(__self__, "configuration", configuration)
        pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def configuration(self) -> builtins.str:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAuditLogResult(dict):
    def __init__(__self__, *,
                 configuration: 'outputs.GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult',
                 enabled: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult(dict):
    def __init__(__self__, *,
                 policy: builtins.str,
                 format: Optional[builtins.str] = None,
                 max_age: Optional[builtins.int] = None,
                 max_backup: Optional[builtins.int] = None,
                 max_size: Optional[builtins.int] = None,
                 path: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def format(self) -> Optional[builtins.str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiEventRateLimitResult(dict):
    def __init__(__self__, *,
                 configuration: builtins.str,
                 enabled: Optional[builtins.bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> builtins.str:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 custom_config: builtins.str,
                 enabled: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeControllerResult(dict):
    def __init__(__self__, *,
                 cluster_cidr: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 service_cluster_ip_range: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.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) -> builtins.str:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> builtins.str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeletResult(dict):
    def __init__(__self__, *,
                 cluster_dns_server: builtins.str,
                 cluster_domain: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 fail_swap_on: builtins.bool,
                 image: builtins.str,
                 infra_container_image: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 generate_serving_certificate: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> builtins.str:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> builtins.bool:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> builtins.str:
        return pulumi.get(self, "infra_container_image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "generate_serving_certificate")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeproxyResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.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, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigServicesSchedulerResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.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, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_input: 'outputs.GetClusterRkeConfigUpgradeStrategyDrainInputResult',
                 drain: Optional[builtins.bool] = None,
                 max_unavailable_controlplane: Optional[builtins.str] = None,
                 max_unavailable_worker: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[builtins.str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[builtins.str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class GetClusterRkeConfigUpgradeStrategyDrainInputResult(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 grace_period: Optional[builtins.int] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[builtins.int]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetClusterTemplateMemberResult(dict):
    def __init__(__self__, *,
                 access_type: Optional[builtins.str] = None,
                 group_principal_id: Optional[builtins.str] = None,
                 user_principal_id: Optional[builtins.str] = None):
        """
        :param builtins.str access_type: Member access type: member, owner, read-only
        :param builtins.str group_principal_id: Member group principal id
        :param builtins.str user_principal_id: Member user principal id
        """
        if access_type is not None:
            pulumi.set(__self__, "access_type", access_type)
        if group_principal_id is not None:
            pulumi.set(__self__, "group_principal_id", group_principal_id)
        if user_principal_id is not None:
            pulumi.set(__self__, "user_principal_id", user_principal_id)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> Optional[builtins.str]:
        """
        Member access type: member, owner, read-only
        """
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="groupPrincipalId")
    def group_principal_id(self) -> Optional[builtins.str]:
        """
        Member group principal id
        """
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[builtins.str]:
        """
        Member user principal id
        """
        return pulumi.get(self, "user_principal_id")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, builtins.str],
                 cluster_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigResult',
                 cluster_template_id: builtins.str,
                 id: builtins.str,
                 labels: Mapping[str, builtins.str],
                 name: builtins.str,
                 default: Optional[builtins.bool] = None,
                 enabled: Optional[builtins.bool] = None,
                 questions: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionQuestionResult']] = None):
        """
        :param Mapping[str, builtins.str] annotations: (Computed) Annotations for the cluster template (map)
        :param 'GetClusterTemplateTemplateRevisionClusterConfigArgs' cluster_config: Cluster configuration
        :param builtins.str cluster_template_id: Cluster template ID
        :param builtins.str id: (Computed) The ID of the resource (string)
        :param Mapping[str, builtins.str] labels: (Computed) Labels for the cluster template (map)
        :param builtins.str name: The cluster template name (string)
        :param builtins.bool default: Default cluster template revision
        :param builtins.bool enabled: Enable cluster template revision
        :param Sequence['GetClusterTemplateTemplateRevisionQuestionArgs'] questions: Cluster template questions
        """
        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, builtins.str]:
        """
        (Computed) Annotations for the cluster template (map)
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterConfig")
    def cluster_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigResult':
        """
        Cluster configuration
        """
        return pulumi.get(self, "cluster_config")

    @property
    @pulumi.getter(name="clusterTemplateId")
    def cluster_template_id(self) -> builtins.str:
        """
        Cluster template ID
        """
        return pulumi.get(self, "cluster_template_id")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        (Computed) Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def default(self) -> Optional[builtins.bool]:
        """
        Default cluster template revision
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Enable cluster template revision
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def questions(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionQuestionResult']]:
        """
        Cluster template questions
        """
        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: builtins.str,
                 default_pod_security_admission_configuration_template_name: builtins.str,
                 desired_agent_image: builtins.str,
                 desired_auth_image: builtins.str,
                 docker_root_dir: builtins.str,
                 rke_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult',
                 enable_network_policy: Optional[builtins.bool] = None,
                 windows_prefered_cluster: Optional[builtins.bool] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs' cluster_auth_endpoint: Local cluster auth endpoint
        :param builtins.str default_cluster_role_for_project_members: Default cluster role for project members
        :param builtins.str default_pod_security_admission_configuration_template_name: Default pod security admission configuration template name
        :param builtins.str desired_agent_image: Desired agent image
        :param builtins.str desired_auth_image: Desired auth image
        :param builtins.str docker_root_dir: Docker Root Dir
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs' rke_config: Rancher Kubernetes Engine Config
        :param builtins.bool enable_network_policy: Enable project network isolation
        :param builtins.bool windows_prefered_cluster: Windows prefered cluster
        """
        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_admission_configuration_template_name", default_pod_security_admission_configuration_template_name)
        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_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if windows_prefered_cluster is not None:
            pulumi.set(__self__, "windows_prefered_cluster", windows_prefered_cluster)

    @property
    @pulumi.getter(name="clusterAuthEndpoint")
    def cluster_auth_endpoint(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult':
        """
        Local cluster auth endpoint
        """
        return pulumi.get(self, "cluster_auth_endpoint")

    @property
    @pulumi.getter(name="defaultClusterRoleForProjectMembers")
    def default_cluster_role_for_project_members(self) -> builtins.str:
        """
        Default cluster role for project members
        """
        return pulumi.get(self, "default_cluster_role_for_project_members")

    @property
    @pulumi.getter(name="defaultPodSecurityAdmissionConfigurationTemplateName")
    def default_pod_security_admission_configuration_template_name(self) -> builtins.str:
        """
        Default pod security admission configuration template name
        """
        return pulumi.get(self, "default_pod_security_admission_configuration_template_name")

    @property
    @pulumi.getter(name="desiredAgentImage")
    def desired_agent_image(self) -> builtins.str:
        """
        Desired agent image
        """
        return pulumi.get(self, "desired_agent_image")

    @property
    @pulumi.getter(name="desiredAuthImage")
    def desired_auth_image(self) -> builtins.str:
        """
        Desired auth image
        """
        return pulumi.get(self, "desired_auth_image")

    @property
    @pulumi.getter(name="dockerRootDir")
    def docker_root_dir(self) -> builtins.str:
        """
        Docker Root Dir
        """
        return pulumi.get(self, "docker_root_dir")

    @property
    @pulumi.getter(name="rkeConfig")
    def rke_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult':
        """
        Rancher Kubernetes Engine Config
        """
        return pulumi.get(self, "rke_config")

    @property
    @pulumi.getter(name="enableNetworkPolicy")
    def enable_network_policy(self) -> Optional[builtins.bool]:
        """
        Enable project network isolation
        """
        return pulumi.get(self, "enable_network_policy")

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[builtins.bool]:
        """
        Windows prefered cluster
        """
        return pulumi.get(self, "windows_prefered_cluster")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[builtins.str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: builtins.int,
                 authentication: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult',
                 authorization: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult',
                 bastion_host: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult',
                 cloud_provider: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult',
                 dns: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult',
                 ingress: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult',
                 kubernetes_version: builtins.str,
                 monitoring: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult',
                 network: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult',
                 prefix_path: builtins.str,
                 services: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult',
                 ssh_cert_path: builtins.str,
                 ssh_key_path: builtins.str,
                 upgrade_strategy: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult',
                 win_prefix_path: builtins.str,
                 addons: Optional[builtins.str] = None,
                 addons_includes: Optional[Sequence[builtins.str]] = None,
                 enable_cri_dockerd: Optional[builtins.bool] = None,
                 ignore_docker_version: Optional[builtins.bool] = None,
                 nodes: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']] = None,
                 private_registries: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult']] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None):
        """
        :param builtins.int addon_job_timeout: Optional duration in seconds of addon job.
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationArgs' authentication: Kubernetes cluster authentication
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationArgs' authorization: Kubernetes cluster authorization
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostArgs' bastion_host: RKE bastion host
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs' ingress: Kubernetes ingress configuration
        :param builtins.str kubernetes_version: Optional kubernetes version to deploy
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs' monitoring: Kubernetes cluster monitoring
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs' network: Kubernetes cluster networking
        :param builtins.str prefix_path: Optional prefix to customize kubernetes path
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs' services: Kubernetes cluster services
        :param builtins.str ssh_cert_path: Optional cluster level SSH certificate path
        :param builtins.str ssh_key_path: Optional cluster level SSH private key path
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param builtins.str win_prefix_path: Optional prefix to customize kubernetes path for windows nodes
        :param builtins.str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[builtins.str] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param builtins.bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param builtins.bool ignore_docker_version: Optional ignore docker version on nodes
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeArgs'] nodes: Optional RKE cluster nodes
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryArgs'] private_registries: Optional private registries for docker images
        :param builtins.bool ssh_agent_auth: Optional use ssh agent auth
        """
        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) -> builtins.int:
        """
        Optional duration in seconds of addon job.
        """
        return pulumi.get(self, "addon_job_timeout")

    @property
    @pulumi.getter
    def authentication(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult':
        """
        Kubernetes cluster authentication
        """
        return pulumi.get(self, "authentication")

    @property
    @pulumi.getter
    def authorization(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult':
        """
        Kubernetes cluster authorization
        """
        return pulumi.get(self, "authorization")

    @property
    @pulumi.getter(name="bastionHost")
    def bastion_host(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult':
        """
        RKE bastion host
        """
        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':
        """
        Kubernetes ingress configuration
        """
        return pulumi.get(self, "ingress")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> builtins.str:
        """
        Optional kubernetes version to deploy
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def monitoring(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult':
        """
        Kubernetes cluster monitoring
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult':
        """
        Kubernetes cluster networking
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="prefixPath")
    def prefix_path(self) -> builtins.str:
        """
        Optional prefix to customize kubernetes path
        """
        return pulumi.get(self, "prefix_path")

    @property
    @pulumi.getter
    def services(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult':
        """
        Kubernetes cluster services
        """
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> builtins.str:
        """
        Optional cluster level SSH certificate path
        """
        return pulumi.get(self, "ssh_cert_path")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> builtins.str:
        """
        Optional cluster level SSH private key path
        """
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult':
        """
        RKE upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")

    @property
    @pulumi.getter(name="winPrefixPath")
    def win_prefix_path(self) -> builtins.str:
        """
        Optional prefix to customize kubernetes path for windows nodes
        """
        return pulumi.get(self, "win_prefix_path")

    @property
    @pulumi.getter
    def addons(self) -> Optional[builtins.str]:
        """
        Optional addons descripton to deploy on rke cluster.
        """
        return pulumi.get(self, "addons")

    @property
    @pulumi.getter(name="addonsIncludes")
    def addons_includes(self) -> Optional[Sequence[builtins.str]]:
        """
        Optional addons yaml manisfest to deploy on rke cluster.
        """
        return pulumi.get(self, "addons_includes")

    @property
    @pulumi.getter(name="enableCriDockerd")
    def enable_cri_dockerd(self) -> Optional[builtins.bool]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[builtins.bool]:
        """
        Optional ignore docker version on nodes
        """
        return pulumi.get(self, "ignore_docker_version")

    @property
    @pulumi.getter
    def nodes(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']]:
        """
        Optional RKE cluster nodes
        """
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter(name="privateRegistries")
    def private_registries(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult']]:
        """
        Optional private registries for docker images
        """
        return pulumi.get(self, "private_registries")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.bool]:
        """
        Optional use ssh agent auth
        """
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult(dict):
    def __init__(__self__, *,
                 sans: Sequence[builtins.str],
                 strategy: builtins.str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "sans")

    @property
    @pulumi.getter
    def strategy(self) -> builtins.str:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, builtins.str],
                 mode: Optional[builtins.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, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def mode(self) -> Optional[builtins.str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult(dict):
    def __init__(__self__, *,
                 address: builtins.str,
                 ssh_key: builtins.str,
                 ssh_key_path: builtins.str,
                 user: builtins.str,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> builtins.str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> builtins.str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult(dict):
    def __init__(__self__, *,
                 custom_cloud_provider: builtins.str,
                 aws_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 name: Optional[builtins.str] = None,
                 openstack_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult'] = None,
                 vsphere_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult'] = None):
        """
        :param builtins.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) -> builtins.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[builtins.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: builtins.str,
                 kubernetes_cluster_id: builtins.str,
                 kubernetes_cluster_tag: builtins.str,
                 role_arn: builtins.str,
                 route_table_id: builtins.str,
                 subnet_id: builtins.str,
                 vpc: builtins.str,
                 zone: builtins.str,
                 disable_security_group_ingress: Optional[builtins.bool] = None,
                 disable_strict_zone_check: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> builtins.str:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> builtins.str:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> builtins.str:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> builtins.str:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> builtins.str:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> builtins.str:
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "disable_strict_zone_check")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult(dict):
    def __init__(__self__, *,
                 region: builtins.str,
                 service: builtins.str,
                 signing_method: builtins.str,
                 signing_name: builtins.str,
                 signing_region: builtins.str,
                 url: builtins.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) -> builtins.str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def service(self) -> builtins.str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> builtins.str:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> builtins.str:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> builtins.str:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> builtins.str:
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult(dict):
    def __init__(__self__, *,
                 aad_client_cert_password: builtins.str,
                 aad_client_cert_path: builtins.str,
                 aad_client_id: builtins.str,
                 aad_client_secret: builtins.str,
                 cloud: builtins.str,
                 cloud_provider_backoff: builtins.bool,
                 cloud_provider_backoff_duration: builtins.int,
                 cloud_provider_backoff_exponent: builtins.int,
                 cloud_provider_backoff_jitter: builtins.int,
                 cloud_provider_backoff_retries: builtins.int,
                 cloud_provider_rate_limit: builtins.bool,
                 cloud_provider_rate_limit_bucket: builtins.int,
                 cloud_provider_rate_limit_qps: builtins.int,
                 location: builtins.str,
                 maximum_load_balancer_rule_count: builtins.int,
                 primary_availability_set_name: builtins.str,
                 primary_scale_set_name: builtins.str,
                 resource_group: builtins.str,
                 route_table_name: builtins.str,
                 security_group_name: builtins.str,
                 subnet_name: builtins.str,
                 subscription_id: builtins.str,
                 tenant_id: builtins.str,
                 use_instance_metadata: builtins.bool,
                 use_managed_identity_extension: builtins.bool,
                 vm_type: builtins.str,
                 vnet_name: builtins.str,
                 vnet_resource_group: builtins.str,
                 load_balancer_sku: Optional[builtins.str] = None):
        """
        :param builtins.str load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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) -> builtins.str:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> builtins.str:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> builtins.str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> builtins.str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter
    def cloud(self) -> builtins.str:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> builtins.bool:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> builtins.bool:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> builtins.int:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter
    def location(self) -> builtins.str:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> builtins.int:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> builtins.str:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> builtins.str:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> builtins.str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> builtins.str:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> builtins.str:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> builtins.str:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> builtins.str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> builtins.str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> builtins.bool:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> builtins.bool:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> builtins.str:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> builtins.str:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> builtins.str:
        return pulumi.get(self, "vnet_resource_group")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[builtins.str]:
        """
        Load balancer type (basic | standard). Must be standard for auto-scaling
        """
        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: builtins.str,
                 ignore_volume_az: builtins.bool,
                 trust_device_path: builtins.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) -> builtins.str:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> builtins.bool:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> builtins.bool:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 auth_url: builtins.str,
                 ca_file: builtins.str,
                 domain_id: builtins.str,
                 domain_name: builtins.str,
                 password: builtins.str,
                 region: builtins.str,
                 tenant_id: builtins.str,
                 tenant_name: builtins.str,
                 trust_id: builtins.str,
                 username: builtins.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) -> builtins.str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> builtins.str:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> builtins.str:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> builtins.str:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> builtins.str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> builtins.str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> builtins.str:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> builtins.str:
        return pulumi.get(self, "trust_id")

    @property
    @pulumi.getter
    def username(self) -> builtins.str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult(dict):
    def __init__(__self__, *,
                 create_monitor: builtins.bool,
                 floating_network_id: builtins.str,
                 lb_method: builtins.str,
                 lb_provider: builtins.str,
                 lb_version: builtins.str,
                 manage_security_groups: builtins.bool,
                 subnet_id: builtins.str,
                 use_octavia: builtins.bool,
                 monitor_delay: Optional[builtins.str] = None,
                 monitor_max_retries: Optional[builtins.int] = None,
                 monitor_timeout: Optional[builtins.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) -> builtins.bool:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> builtins.str:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> builtins.str:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> builtins.str:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> builtins.str:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> builtins.bool:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> builtins.bool:
        return pulumi.get(self, "use_octavia")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[builtins.str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[builtins.int]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[builtins.str]:
        return pulumi.get(self, "monitor_timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataResult(dict):
    def __init__(__self__, *,
                 request_timeout: builtins.int,
                 search_order: builtins.str):
        pulumi.set(__self__, "request_timeout", request_timeout)
        pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> builtins.int:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> builtins.str:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteResult(dict):
    def __init__(__self__, *,
                 router_id: builtins.str):
        pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> builtins.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: builtins.str):
        pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> builtins.str:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 datacenters: builtins.str,
                 insecure_flag: builtins.bool,
                 password: builtins.str,
                 port: builtins.str,
                 soap_roundtrip_count: builtins.int,
                 user: builtins.str,
                 graceful_shutdown_timeout: Optional[builtins.str] = None):
        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)
        if graceful_shutdown_timeout is not None:
            pulumi.set(__self__, "graceful_shutdown_timeout", graceful_shutdown_timeout)

    @property
    @pulumi.getter
    def datacenters(self) -> builtins.str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> builtins.bool:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> builtins.int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[builtins.str]:
        return pulumi.get(self, "graceful_shutdown_timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult(dict):
    def __init__(__self__, *,
                 public_network: builtins.str):
        pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> builtins.str:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult(dict):
    def __init__(__self__, *,
                 datacenters: builtins.str,
                 name: builtins.str,
                 password: builtins.str,
                 port: builtins.str,
                 soap_roundtrip_count: builtins.int,
                 user: builtins.str):
        """
        :param builtins.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) -> builtins.str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> builtins.int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult(dict):
    def __init__(__self__, *,
                 datacenter: builtins.str,
                 default_datastore: builtins.str,
                 folder: builtins.str,
                 resourcepool_path: builtins.str,
                 server: builtins.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) -> builtins.str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> builtins.str:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter
    def folder(self) -> builtins.str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> builtins.str:
        return pulumi.get(self, "resourcepool_path")

    @property
    @pulumi.getter
    def server(self) -> builtins.str:
        return pulumi.get(self, "server")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult(dict):
    def __init__(__self__, *,
                 node_selector: Mapping[str, builtins.str],
                 options: Mapping[str, builtins.str],
                 reverse_cidrs: Sequence[builtins.str],
                 upstream_nameservers: Sequence[builtins.str],
                 linear_autoscaler_params: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult'] = None,
                 nodelocal: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[builtins.str] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult'] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsArgs' linear_autoscaler_params: Linear Autoscaler Params
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationArgs'] tolerations: DNS service tolerations
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        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, builtins.str]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "upstream_nameservers")

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult']:
        """
        Linear Autoscaler Params
        """
        return pulumi.get(self, "linear_autoscaler_params")

    @property
    @pulumi.getter
    def nodelocal(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult']:
        """
        Nodelocal dns
        """
        return pulumi.get(self, "nodelocal")

    @property
    @pulumi.getter
    def provider(self) -> Optional[builtins.str]:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult']]:
        """
        DNS service tolerations
        """
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult']:
        """
        Update deployment strategy
        """
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult(dict):
    def __init__(__self__, *,
                 cores_per_replica: Optional[builtins.float] = None,
                 max: Optional[builtins.int] = None,
                 min: Optional[builtins.int] = None,
                 nodes_per_replica: Optional[builtins.float] = None,
                 prevent_single_point_failure: Optional[builtins.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[builtins.float]:
        return pulumi.get(self, "cores_per_replica")

    @property
    @pulumi.getter
    def max(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional[builtins.int]:
        return pulumi.get(self, "min")

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[builtins.float]:
        return pulumi.get(self, "nodes_per_replica")

    @property
    @pulumi.getter(name="preventSinglePointFailure")
    def prevent_single_point_failure(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "prevent_single_point_failure")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult(dict):
    def __init__(__self__, *,
                 ip_address: Optional[builtins.str] = None,
                 node_selector: Optional[Mapping[str, builtins.str]] = None):
        """
        :param Mapping[str, builtins.str] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[builtins.str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[builtins.str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 http_port: builtins.int,
                 https_port: builtins.int,
                 network_mode: builtins.str,
                 node_selector: Mapping[str, builtins.str],
                 options: Mapping[str, builtins.str],
                 provider: builtins.str,
                 default_backend: Optional[builtins.bool] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult'] = None):
        """
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationArgs'] tolerations: Ingress add-on tolerations
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyArgs' update_strategy: Update daemon set strategy
        """
        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) -> builtins.str:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> builtins.int:
        return pulumi.get(self, "http_port")

    @property
    @pulumi.getter(name="httpsPort")
    def https_port(self) -> builtins.int:
        return pulumi.get(self, "https_port")

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> builtins.str:
        return pulumi.get(self, "network_mode")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> builtins.str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter(name="defaultBackend")
    def default_backend(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "default_backend")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult']]:
        """
        Ingress add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult']:
        """
        Update daemon set strategy
        """
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[builtins.str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, builtins.str],
                 provider: builtins.str,
                 replicas: builtins.int,
                 node_selector: Optional[Mapping[str, builtins.str]] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult'] = None):
        """
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationArgs'] tolerations: Monitoring add-on tolerations
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        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, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> builtins.str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> builtins.int:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, builtins.str]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult']]:
        """
        Monitoring add-on tolerations
        """
        return pulumi.get(self, "tolerations")

    @property
    @pulumi.getter(name="updateStrategy")
    def update_strategy(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult']:
        """
        Update deployment strategy
        """
        return pulumi.get(self, "update_strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[builtins.str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param builtins.str strategy: Strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult']:
        """
        Rolling update for update strategy
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def strategy(self) -> Optional[builtins.str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[builtins.int] = None,
                 max_unavailable: Optional[builtins.int] = None):
        """
        :param builtins.int max_surge: Rolling update max surge
        :param builtins.int max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, builtins.str],
                 plugin: builtins.str,
                 aci_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderResult'] = None,
                 calico_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult'] = None,
                 canal_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult'] = None,
                 flannel_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult'] = None,
                 mtu: Optional[builtins.int] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult']] = None,
                 weave_network_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult'] = None):
        """
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationArgs'] tolerations: Network add-on tolerations
        """
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "plugin", plugin)
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if 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, builtins.str]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> builtins.str:
        return pulumi.get(self, "plugin")

    @property
    @pulumi.getter(name="aciNetworkProvider")
    def aci_network_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderResult']:
        return pulumi.get(self, "aci_network_provider")

    @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[builtins.int]:
        return pulumi.get(self, "mtu")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult']]:
        """
        Network add-on tolerations
        """
        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 GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkAciNetworkProviderResult(dict):
    def __init__(__self__, *,
                 aep: builtins.str,
                 apic_hosts: Sequence[builtins.str],
                 apic_user_crt: builtins.str,
                 apic_user_key: builtins.str,
                 apic_user_name: builtins.str,
                 encap_type: builtins.str,
                 extern_dynamic: builtins.str,
                 extern_static: builtins.str,
                 kube_api_vlan: builtins.str,
                 l3out: builtins.str,
                 l3out_external_networks: Sequence[builtins.str],
                 mcast_range_end: builtins.str,
                 mcast_range_start: builtins.str,
                 node_subnet: builtins.str,
                 node_svc_subnet: builtins.str,
                 service_vlan: builtins.str,
                 system_id: builtins.str,
                 token: builtins.str,
                 vrf_name: builtins.str,
                 vrf_tenant: builtins.str,
                 apic_refresh_ticker_adjust: Optional[builtins.str] = None,
                 apic_refresh_time: Optional[builtins.str] = None,
                 apic_subscription_delay: Optional[builtins.str] = None,
                 capic: Optional[builtins.str] = None,
                 controller_log_level: Optional[builtins.str] = None,
                 disable_periodic_snat_global_info_sync: Optional[builtins.str] = None,
                 disable_wait_for_network: Optional[builtins.str] = None,
                 drop_log_enable: Optional[builtins.str] = None,
                 duration_wait_for_network: Optional[builtins.str] = None,
                 enable_endpoint_slice: Optional[builtins.str] = None,
                 ep_registry: Optional[builtins.str] = None,
                 gbp_pod_subnet: Optional[builtins.str] = None,
                 host_agent_log_level: Optional[builtins.str] = None,
                 image_pull_policy: Optional[builtins.str] = None,
                 image_pull_secret: Optional[builtins.str] = None,
                 infra_vlan: Optional[builtins.str] = None,
                 install_istio: Optional[builtins.str] = None,
                 istio_profile: Optional[builtins.str] = None,
                 kafka_brokers: Optional[Sequence[builtins.str]] = None,
                 kafka_client_crt: Optional[builtins.str] = None,
                 kafka_client_key: Optional[builtins.str] = None,
                 max_nodes_svc_graph: Optional[builtins.str] = None,
                 mtu_head_room: Optional[builtins.str] = None,
                 multus_disable: Optional[builtins.str] = None,
                 no_priority_class: Optional[builtins.str] = None,
                 node_pod_if_enable: Optional[builtins.str] = None,
                 opflex_client_ssl: Optional[builtins.str] = None,
                 opflex_device_delete_timeout: Optional[builtins.str] = None,
                 opflex_log_level: Optional[builtins.str] = None,
                 opflex_mode: Optional[builtins.str] = None,
                 opflex_server_port: Optional[builtins.str] = None,
                 overlay_vrf_name: Optional[builtins.str] = None,
                 ovs_memory_limit: Optional[builtins.str] = None,
                 pbr_tracking_non_snat: Optional[builtins.str] = None,
                 pod_subnet_chunk_size: Optional[builtins.str] = None,
                 run_gbp_container: Optional[builtins.str] = None,
                 run_opflex_server_container: Optional[builtins.str] = None,
                 service_monitor_interval: Optional[builtins.str] = None,
                 snat_contract_scope: Optional[builtins.str] = None,
                 snat_namespace: Optional[builtins.str] = None,
                 snat_port_range_end: Optional[builtins.str] = None,
                 snat_port_range_start: Optional[builtins.str] = None,
                 snat_ports_per_node: Optional[builtins.str] = None,
                 sriov_enable: Optional[builtins.str] = None,
                 subnet_domain_name: Optional[builtins.str] = None,
                 tenant: Optional[builtins.str] = None,
                 use_aci_anywhere_crd: Optional[builtins.str] = None,
                 use_aci_cni_priority_class: Optional[builtins.str] = None,
                 use_cluster_role: Optional[builtins.str] = None,
                 use_host_netns_volume: Optional[builtins.str] = None,
                 use_opflex_server_volume: Optional[builtins.str] = None,
                 use_privileged_container: Optional[builtins.str] = None,
                 vmm_controller: Optional[builtins.str] = None,
                 vmm_domain: Optional[builtins.str] = None):
        pulumi.set(__self__, "aep", aep)
        pulumi.set(__self__, "apic_hosts", apic_hosts)
        pulumi.set(__self__, "apic_user_crt", apic_user_crt)
        pulumi.set(__self__, "apic_user_key", apic_user_key)
        pulumi.set(__self__, "apic_user_name", apic_user_name)
        pulumi.set(__self__, "encap_type", encap_type)
        pulumi.set(__self__, "extern_dynamic", extern_dynamic)
        pulumi.set(__self__, "extern_static", extern_static)
        pulumi.set(__self__, "kube_api_vlan", kube_api_vlan)
        pulumi.set(__self__, "l3out", l3out)
        pulumi.set(__self__, "l3out_external_networks", l3out_external_networks)
        pulumi.set(__self__, "mcast_range_end", mcast_range_end)
        pulumi.set(__self__, "mcast_range_start", mcast_range_start)
        pulumi.set(__self__, "node_subnet", node_subnet)
        pulumi.set(__self__, "node_svc_subnet", node_svc_subnet)
        pulumi.set(__self__, "service_vlan", service_vlan)
        pulumi.set(__self__, "system_id", system_id)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "vrf_name", vrf_name)
        pulumi.set(__self__, "vrf_tenant", vrf_tenant)
        if apic_refresh_ticker_adjust is not None:
            pulumi.set(__self__, "apic_refresh_ticker_adjust", apic_refresh_ticker_adjust)
        if apic_refresh_time is not None:
            pulumi.set(__self__, "apic_refresh_time", apic_refresh_time)
        if apic_subscription_delay is not None:
            pulumi.set(__self__, "apic_subscription_delay", apic_subscription_delay)
        if capic is not None:
            pulumi.set(__self__, "capic", capic)
        if controller_log_level is not None:
            pulumi.set(__self__, "controller_log_level", controller_log_level)
        if disable_periodic_snat_global_info_sync is not None:
            pulumi.set(__self__, "disable_periodic_snat_global_info_sync", disable_periodic_snat_global_info_sync)
        if disable_wait_for_network is not None:
            pulumi.set(__self__, "disable_wait_for_network", disable_wait_for_network)
        if drop_log_enable is not None:
            pulumi.set(__self__, "drop_log_enable", drop_log_enable)
        if duration_wait_for_network is not None:
            pulumi.set(__self__, "duration_wait_for_network", duration_wait_for_network)
        if enable_endpoint_slice is not None:
            pulumi.set(__self__, "enable_endpoint_slice", enable_endpoint_slice)
        if ep_registry is not None:
            pulumi.set(__self__, "ep_registry", ep_registry)
        if gbp_pod_subnet is not None:
            pulumi.set(__self__, "gbp_pod_subnet", gbp_pod_subnet)
        if host_agent_log_level is not None:
            pulumi.set(__self__, "host_agent_log_level", host_agent_log_level)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if image_pull_secret is not None:
            pulumi.set(__self__, "image_pull_secret", image_pull_secret)
        if infra_vlan is not None:
            pulumi.set(__self__, "infra_vlan", infra_vlan)
        if install_istio is not None:
            pulumi.set(__self__, "install_istio", install_istio)
        if istio_profile is not None:
            pulumi.set(__self__, "istio_profile", istio_profile)
        if kafka_brokers is not None:
            pulumi.set(__self__, "kafka_brokers", kafka_brokers)
        if kafka_client_crt is not None:
            pulumi.set(__self__, "kafka_client_crt", kafka_client_crt)
        if kafka_client_key is not None:
            pulumi.set(__self__, "kafka_client_key", kafka_client_key)
        if max_nodes_svc_graph is not None:
            pulumi.set(__self__, "max_nodes_svc_graph", max_nodes_svc_graph)
        if mtu_head_room is not None:
            pulumi.set(__self__, "mtu_head_room", mtu_head_room)
        if multus_disable is not None:
            pulumi.set(__self__, "multus_disable", multus_disable)
        if no_priority_class is not None:
            pulumi.set(__self__, "no_priority_class", no_priority_class)
        if node_pod_if_enable is not None:
            pulumi.set(__self__, "node_pod_if_enable", node_pod_if_enable)
        if opflex_client_ssl is not None:
            pulumi.set(__self__, "opflex_client_ssl", opflex_client_ssl)
        if opflex_device_delete_timeout is not None:
            pulumi.set(__self__, "opflex_device_delete_timeout", opflex_device_delete_timeout)
        if opflex_log_level is not None:
            pulumi.set(__self__, "opflex_log_level", opflex_log_level)
        if opflex_mode is not None:
            pulumi.set(__self__, "opflex_mode", opflex_mode)
        if opflex_server_port is not None:
            pulumi.set(__self__, "opflex_server_port", opflex_server_port)
        if overlay_vrf_name is not None:
            pulumi.set(__self__, "overlay_vrf_name", overlay_vrf_name)
        if ovs_memory_limit is not None:
            pulumi.set(__self__, "ovs_memory_limit", ovs_memory_limit)
        if pbr_tracking_non_snat is not None:
            pulumi.set(__self__, "pbr_tracking_non_snat", pbr_tracking_non_snat)
        if pod_subnet_chunk_size is not None:
            pulumi.set(__self__, "pod_subnet_chunk_size", pod_subnet_chunk_size)
        if run_gbp_container is not None:
            pulumi.set(__self__, "run_gbp_container", run_gbp_container)
        if run_opflex_server_container is not None:
            pulumi.set(__self__, "run_opflex_server_container", run_opflex_server_container)
        if service_monitor_interval is not None:
            pulumi.set(__self__, "service_monitor_interval", service_monitor_interval)
        if snat_contract_scope is not None:
            pulumi.set(__self__, "snat_contract_scope", snat_contract_scope)
        if snat_namespace is not None:
            pulumi.set(__self__, "snat_namespace", snat_namespace)
        if snat_port_range_end is not None:
            pulumi.set(__self__, "snat_port_range_end", snat_port_range_end)
        if snat_port_range_start is not None:
            pulumi.set(__self__, "snat_port_range_start", snat_port_range_start)
        if snat_ports_per_node is not None:
            pulumi.set(__self__, "snat_ports_per_node", snat_ports_per_node)
        if sriov_enable is not None:
            pulumi.set(__self__, "sriov_enable", sriov_enable)
        if subnet_domain_name is not None:
            pulumi.set(__self__, "subnet_domain_name", subnet_domain_name)
        if tenant is not None:
            pulumi.set(__self__, "tenant", tenant)
        if use_aci_anywhere_crd is not None:
            pulumi.set(__self__, "use_aci_anywhere_crd", use_aci_anywhere_crd)
        if use_aci_cni_priority_class is not None:
            pulumi.set(__self__, "use_aci_cni_priority_class", use_aci_cni_priority_class)
        if use_cluster_role is not None:
            pulumi.set(__self__, "use_cluster_role", use_cluster_role)
        if use_host_netns_volume is not None:
            pulumi.set(__self__, "use_host_netns_volume", use_host_netns_volume)
        if use_opflex_server_volume is not None:
            pulumi.set(__self__, "use_opflex_server_volume", use_opflex_server_volume)
        if use_privileged_container is not None:
            pulumi.set(__self__, "use_privileged_container", use_privileged_container)
        if vmm_controller is not None:
            pulumi.set(__self__, "vmm_controller", vmm_controller)
        if vmm_domain is not None:
            pulumi.set(__self__, "vmm_domain", vmm_domain)

    @property
    @pulumi.getter
    def aep(self) -> builtins.str:
        return pulumi.get(self, "aep")

    @property
    @pulumi.getter(name="apicHosts")
    def apic_hosts(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "apic_hosts")

    @property
    @pulumi.getter(name="apicUserCrt")
    def apic_user_crt(self) -> builtins.str:
        return pulumi.get(self, "apic_user_crt")

    @property
    @pulumi.getter(name="apicUserKey")
    def apic_user_key(self) -> builtins.str:
        return pulumi.get(self, "apic_user_key")

    @property
    @pulumi.getter(name="apicUserName")
    def apic_user_name(self) -> builtins.str:
        return pulumi.get(self, "apic_user_name")

    @property
    @pulumi.getter(name="encapType")
    def encap_type(self) -> builtins.str:
        return pulumi.get(self, "encap_type")

    @property
    @pulumi.getter(name="externDynamic")
    def extern_dynamic(self) -> builtins.str:
        return pulumi.get(self, "extern_dynamic")

    @property
    @pulumi.getter(name="externStatic")
    def extern_static(self) -> builtins.str:
        return pulumi.get(self, "extern_static")

    @property
    @pulumi.getter(name="kubeApiVlan")
    def kube_api_vlan(self) -> builtins.str:
        return pulumi.get(self, "kube_api_vlan")

    @property
    @pulumi.getter
    def l3out(self) -> builtins.str:
        return pulumi.get(self, "l3out")

    @property
    @pulumi.getter(name="l3outExternalNetworks")
    def l3out_external_networks(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "l3out_external_networks")

    @property
    @pulumi.getter(name="mcastRangeEnd")
    def mcast_range_end(self) -> builtins.str:
        return pulumi.get(self, "mcast_range_end")

    @property
    @pulumi.getter(name="mcastRangeStart")
    def mcast_range_start(self) -> builtins.str:
        return pulumi.get(self, "mcast_range_start")

    @property
    @pulumi.getter(name="nodeSubnet")
    def node_subnet(self) -> builtins.str:
        return pulumi.get(self, "node_subnet")

    @property
    @pulumi.getter(name="nodeSvcSubnet")
    def node_svc_subnet(self) -> builtins.str:
        return pulumi.get(self, "node_svc_subnet")

    @property
    @pulumi.getter(name="serviceVlan")
    def service_vlan(self) -> builtins.str:
        return pulumi.get(self, "service_vlan")

    @property
    @pulumi.getter(name="systemId")
    def system_id(self) -> builtins.str:
        return pulumi.get(self, "system_id")

    @property
    @pulumi.getter
    def token(self) -> builtins.str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="vrfName")
    def vrf_name(self) -> builtins.str:
        return pulumi.get(self, "vrf_name")

    @property
    @pulumi.getter(name="vrfTenant")
    def vrf_tenant(self) -> builtins.str:
        return pulumi.get(self, "vrf_tenant")

    @property
    @pulumi.getter(name="apicRefreshTickerAdjust")
    def apic_refresh_ticker_adjust(self) -> Optional[builtins.str]:
        return pulumi.get(self, "apic_refresh_ticker_adjust")

    @property
    @pulumi.getter(name="apicRefreshTime")
    def apic_refresh_time(self) -> Optional[builtins.str]:
        return pulumi.get(self, "apic_refresh_time")

    @property
    @pulumi.getter(name="apicSubscriptionDelay")
    def apic_subscription_delay(self) -> Optional[builtins.str]:
        return pulumi.get(self, "apic_subscription_delay")

    @property
    @pulumi.getter
    def capic(self) -> Optional[builtins.str]:
        return pulumi.get(self, "capic")

    @property
    @pulumi.getter(name="controllerLogLevel")
    def controller_log_level(self) -> Optional[builtins.str]:
        return pulumi.get(self, "controller_log_level")

    @property
    @pulumi.getter(name="disablePeriodicSnatGlobalInfoSync")
    def disable_periodic_snat_global_info_sync(self) -> Optional[builtins.str]:
        return pulumi.get(self, "disable_periodic_snat_global_info_sync")

    @property
    @pulumi.getter(name="disableWaitForNetwork")
    def disable_wait_for_network(self) -> Optional[builtins.str]:
        return pulumi.get(self, "disable_wait_for_network")

    @property
    @pulumi.getter(name="dropLogEnable")
    def drop_log_enable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "drop_log_enable")

    @property
    @pulumi.getter(name="durationWaitForNetwork")
    def duration_wait_for_network(self) -> Optional[builtins.str]:
        return pulumi.get(self, "duration_wait_for_network")

    @property
    @pulumi.getter(name="enableEndpointSlice")
    def enable_endpoint_slice(self) -> Optional[builtins.str]:
        return pulumi.get(self, "enable_endpoint_slice")

    @property
    @pulumi.getter(name="epRegistry")
    def ep_registry(self) -> Optional[builtins.str]:
        return pulumi.get(self, "ep_registry")

    @property
    @pulumi.getter(name="gbpPodSubnet")
    def gbp_pod_subnet(self) -> Optional[builtins.str]:
        return pulumi.get(self, "gbp_pod_subnet")

    @property
    @pulumi.getter(name="hostAgentLogLevel")
    def host_agent_log_level(self) -> Optional[builtins.str]:
        return pulumi.get(self, "host_agent_log_level")

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[builtins.str]:
        return pulumi.get(self, "image_pull_policy")

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[builtins.str]:
        return pulumi.get(self, "image_pull_secret")

    @property
    @pulumi.getter(name="infraVlan")
    def infra_vlan(self) -> Optional[builtins.str]:
        return pulumi.get(self, "infra_vlan")

    @property
    @pulumi.getter(name="installIstio")
    def install_istio(self) -> Optional[builtins.str]:
        return pulumi.get(self, "install_istio")

    @property
    @pulumi.getter(name="istioProfile")
    def istio_profile(self) -> Optional[builtins.str]:
        return pulumi.get(self, "istio_profile")

    @property
    @pulumi.getter(name="kafkaBrokers")
    def kafka_brokers(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "kafka_brokers")

    @property
    @pulumi.getter(name="kafkaClientCrt")
    def kafka_client_crt(self) -> Optional[builtins.str]:
        return pulumi.get(self, "kafka_client_crt")

    @property
    @pulumi.getter(name="kafkaClientKey")
    def kafka_client_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "kafka_client_key")

    @property
    @pulumi.getter(name="maxNodesSvcGraph")
    def max_nodes_svc_graph(self) -> Optional[builtins.str]:
        return pulumi.get(self, "max_nodes_svc_graph")

    @property
    @pulumi.getter(name="mtuHeadRoom")
    def mtu_head_room(self) -> Optional[builtins.str]:
        return pulumi.get(self, "mtu_head_room")

    @property
    @pulumi.getter(name="multusDisable")
    def multus_disable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "multus_disable")

    @property
    @pulumi.getter(name="noPriorityClass")
    def no_priority_class(self) -> Optional[builtins.str]:
        return pulumi.get(self, "no_priority_class")

    @property
    @pulumi.getter(name="nodePodIfEnable")
    def node_pod_if_enable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "node_pod_if_enable")

    @property
    @pulumi.getter(name="opflexClientSsl")
    def opflex_client_ssl(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_client_ssl")

    @property
    @pulumi.getter(name="opflexDeviceDeleteTimeout")
    def opflex_device_delete_timeout(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_device_delete_timeout")

    @property
    @pulumi.getter(name="opflexLogLevel")
    def opflex_log_level(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_log_level")

    @property
    @pulumi.getter(name="opflexMode")
    def opflex_mode(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_mode")

    @property
    @pulumi.getter(name="opflexServerPort")
    def opflex_server_port(self) -> Optional[builtins.str]:
        return pulumi.get(self, "opflex_server_port")

    @property
    @pulumi.getter(name="overlayVrfName")
    def overlay_vrf_name(self) -> Optional[builtins.str]:
        return pulumi.get(self, "overlay_vrf_name")

    @property
    @pulumi.getter(name="ovsMemoryLimit")
    def ovs_memory_limit(self) -> Optional[builtins.str]:
        return pulumi.get(self, "ovs_memory_limit")

    @property
    @pulumi.getter(name="pbrTrackingNonSnat")
    def pbr_tracking_non_snat(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pbr_tracking_non_snat")

    @property
    @pulumi.getter(name="podSubnetChunkSize")
    def pod_subnet_chunk_size(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pod_subnet_chunk_size")

    @property
    @pulumi.getter(name="runGbpContainer")
    def run_gbp_container(self) -> Optional[builtins.str]:
        return pulumi.get(self, "run_gbp_container")

    @property
    @pulumi.getter(name="runOpflexServerContainer")
    def run_opflex_server_container(self) -> Optional[builtins.str]:
        return pulumi.get(self, "run_opflex_server_container")

    @property
    @pulumi.getter(name="serviceMonitorInterval")
    def service_monitor_interval(self) -> Optional[builtins.str]:
        return pulumi.get(self, "service_monitor_interval")

    @property
    @pulumi.getter(name="snatContractScope")
    def snat_contract_scope(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_contract_scope")

    @property
    @pulumi.getter(name="snatNamespace")
    def snat_namespace(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_namespace")

    @property
    @pulumi.getter(name="snatPortRangeEnd")
    def snat_port_range_end(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_port_range_end")

    @property
    @pulumi.getter(name="snatPortRangeStart")
    def snat_port_range_start(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_port_range_start")

    @property
    @pulumi.getter(name="snatPortsPerNode")
    def snat_ports_per_node(self) -> Optional[builtins.str]:
        return pulumi.get(self, "snat_ports_per_node")

    @property
    @pulumi.getter(name="sriovEnable")
    def sriov_enable(self) -> Optional[builtins.str]:
        return pulumi.get(self, "sriov_enable")

    @property
    @pulumi.getter(name="subnetDomainName")
    def subnet_domain_name(self) -> Optional[builtins.str]:
        return pulumi.get(self, "subnet_domain_name")

    @property
    @pulumi.getter
    def tenant(self) -> Optional[builtins.str]:
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter(name="useAciAnywhereCrd")
    def use_aci_anywhere_crd(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_aci_anywhere_crd")

    @property
    @pulumi.getter(name="useAciCniPriorityClass")
    def use_aci_cni_priority_class(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_aci_cni_priority_class")

    @property
    @pulumi.getter(name="useClusterRole")
    def use_cluster_role(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_cluster_role")

    @property
    @pulumi.getter(name="useHostNetnsVolume")
    def use_host_netns_volume(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_host_netns_volume")

    @property
    @pulumi.getter(name="useOpflexServerVolume")
    def use_opflex_server_volume(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_opflex_server_volume")

    @property
    @pulumi.getter(name="usePrivilegedContainer")
    def use_privileged_container(self) -> Optional[builtins.str]:
        return pulumi.get(self, "use_privileged_container")

    @property
    @pulumi.getter(name="vmmController")
    def vmm_controller(self) -> Optional[builtins.str]:
        return pulumi.get(self, "vmm_controller")

    @property
    @pulumi.getter(name="vmmDomain")
    def vmm_domain(self) -> Optional[builtins.str]:
        return pulumi.get(self, "vmm_domain")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult(dict):
    def __init__(__self__, *,
                 cloud_provider: builtins.str):
        pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> builtins.str:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: builtins.str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> builtins.str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: builtins.str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> builtins.str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 seconds: builtins.int,
                 effect: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 value: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> builtins.int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult(dict):
    def __init__(__self__, *,
                 password: builtins.str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        return pulumi.get(self, "password")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult(dict):
    def __init__(__self__, *,
                 address: builtins.str,
                 docker_socket: builtins.str,
                 roles: Sequence[builtins.str],
                 ssh_key: builtins.str,
                 ssh_key_path: builtins.str,
                 user: builtins.str,
                 hostname_override: Optional[builtins.str] = None,
                 internal_address: Optional[builtins.str] = None,
                 labels: Optional[Mapping[str, builtins.str]] = None,
                 node_id: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 ssh_agent_auth: Optional[builtins.bool] = None):
        """
        :param Mapping[str, builtins.str] 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) -> builtins.str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> builtins.str:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[builtins.str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> builtins.str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> builtins.str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> builtins.str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[builtins.str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[builtins.str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        (Computed) Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[builtins.str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult(dict):
    def __init__(__self__, *,
                 url: builtins.str,
                 ecr_credential_plugin: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult'] = None,
                 is_default: Optional[builtins.bool] = None,
                 password: Optional[builtins.str] = None,
                 user: Optional[builtins.str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginArgs' ecr_credential_plugin: ECR credential plugin config
        """
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def url(self) -> builtins.str:
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="ecrCredentialPlugin")
    def ecr_credential_plugin(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult']:
        """
        ECR credential plugin config
        """
        return pulumi.get(self, "ecr_credential_plugin")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[builtins.str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult(dict):
    def __init__(__self__, *,
                 aws_access_key_id: Optional[builtins.str] = None,
                 aws_secret_access_key: Optional[builtins.str] = None,
                 aws_session_token: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "aws_access_key_id")

    @property
    @pulumi.getter(name="awsSecretAccessKey")
    def aws_secret_access_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "aws_secret_access_key")

    @property
    @pulumi.getter(name="awsSessionToken")
    def aws_session_token(self) -> Optional[builtins.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: builtins.str,
                 cert: builtins.str,
                 creation: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 key: builtins.str,
                 path: builtins.str,
                 retention: builtins.str,
                 snapshot: builtins.bool,
                 external_urls: Optional[Sequence[builtins.str]] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 gid: Optional[builtins.int] = None,
                 uid: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> builtins.str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> builtins.str:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> builtins.str:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> builtins.bool:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[builtins.int]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def uid(self) -> Optional[builtins.int]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: builtins.int,
                 enabled: Optional[builtins.bool] = None,
                 interval_hours: Optional[builtins.int] = None,
                 retention: Optional[builtins.int] = None,
                 s3_backup_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[builtins.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) -> builtins.int:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[builtins.int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: builtins.str,
                 endpoint: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 custom_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> builtins.str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[builtins.str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 service_cluster_ip_range: builtins.str,
                 service_node_port_range: builtins.str,
                 admission_configuration: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult'] = None,
                 always_pull_images: Optional[builtins.bool] = None,
                 audit_log: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult'] = None,
                 event_rate_limit: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult'] = None,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 secrets_encryption_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult'] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationArgs' admission_configuration: Cluster admission configuration
        """
        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 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, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> builtins.str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> builtins.str:
        return pulumi.get(self, "service_node_port_range")

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[builtins.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[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult']:
        return pulumi.get(self, "secrets_encryption_config")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult(dict):
    def __init__(__self__, *,
                 plugins: Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginResult'],
                 api_version: Optional[builtins.str] = None,
                 kind: Optional[builtins.str] = None):
        """
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs'] plugins: Admission configuration plugins
        :param builtins.str api_version: Admission configuration ApiVersion
        :param builtins.str kind: Admission configuration Kind
        """
        pulumi.set(__self__, "plugins", plugins)
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)

    @property
    @pulumi.getter
    def plugins(self) -> Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginResult']:
        """
        Admission configuration plugins
        """
        return pulumi.get(self, "plugins")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[builtins.str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[builtins.str]:
        """
        Admission configuration Kind
        """
        return pulumi.get(self, "kind")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginResult(dict):
    def __init__(__self__, *,
                 configuration: builtins.str,
                 name: builtins.str,
                 path: Optional[builtins.str] = None):
        """
        :param builtins.str configuration: Plugin configuration
        :param builtins.str name: The cluster template name (string)
        :param builtins.str path: Plugin path
        """
        pulumi.set(__self__, "configuration", configuration)
        pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def configuration(self) -> builtins.str:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult(dict):
    def __init__(__self__, *,
                 configuration: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult',
                 enabled: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult(dict):
    def __init__(__self__, *,
                 policy: builtins.str,
                 format: Optional[builtins.str] = None,
                 max_age: Optional[builtins.int] = None,
                 max_backup: Optional[builtins.int] = None,
                 max_size: Optional[builtins.int] = None,
                 path: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def format(self) -> Optional[builtins.str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[builtins.int]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult(dict):
    def __init__(__self__, *,
                 configuration: builtins.str,
                 enabled: Optional[builtins.bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> builtins.str:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 custom_config: builtins.str,
                 enabled: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult(dict):
    def __init__(__self__, *,
                 cluster_cidr: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 service_cluster_ip_range: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.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) -> builtins.str:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> builtins.str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult(dict):
    def __init__(__self__, *,
                 cluster_dns_server: builtins.str,
                 cluster_domain: builtins.str,
                 extra_args: Mapping[str, builtins.str],
                 fail_swap_on: builtins.bool,
                 image: builtins.str,
                 infra_container_image: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.str]] = None,
                 generate_serving_certificate: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> builtins.str:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> builtins.bool:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> builtins.str:
        return pulumi.get(self, "infra_container_image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "generate_serving_certificate")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.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, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, builtins.str],
                 image: builtins.str,
                 extra_binds: Optional[Sequence[builtins.str]] = None,
                 extra_envs: Optional[Sequence[builtins.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, builtins.str]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[builtins.str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_input: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult',
                 drain: Optional[builtins.bool] = None,
                 max_unavailable_controlplane: Optional[builtins.str] = None,
                 max_unavailable_worker: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[builtins.str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[builtins.str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 grace_period: Optional[builtins.int] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 timeout: Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[builtins.int]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionQuestionResult(dict):
    def __init__(__self__, *,
                 default: builtins.str,
                 variable: builtins.str,
                 required: Optional[builtins.bool] = None,
                 type: Optional[builtins.str] = None):
        """
        :param builtins.str default: Default variable value
        :param builtins.str variable: Variable name
        :param builtins.bool required: Required variable
        :param builtins.str type: Variable type
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "variable", variable)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def default(self) -> builtins.str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> builtins.str:
        """
        Variable name
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[builtins.bool]:
        """
        Required variable
        """
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        Variable type
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetClusterV2AgentEnvVarResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 value: builtins.str):
        """
        :param builtins.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) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterV2ClusterRegistrationTokenResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, builtins.str],
                 cluster_id: builtins.str,
                 command: builtins.str,
                 id: builtins.str,
                 insecure_command: builtins.str,
                 insecure_node_command: builtins.str,
                 insecure_windows_node_command: builtins.str,
                 labels: Mapping[str, builtins.str],
                 manifest_url: builtins.str,
                 name: builtins.str,
                 node_command: builtins.str,
                 token: builtins.str,
                 windows_node_command: builtins.str):
        """
        :param Mapping[str, builtins.str] annotations: Annotations of the resource
        :param builtins.str id: (Computed) The ID of the resource (string)
        :param Mapping[str, builtins.str] labels: Labels of the resource
        :param builtins.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, builtins.str]:
        """
        Annotations of the resource
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> builtins.str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> builtins.str:
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> builtins.str:
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter(name="insecureNodeCommand")
    def insecure_node_command(self) -> builtins.str:
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> builtins.str:
        return pulumi.get(self, "insecure_windows_node_command")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        Labels of the resource
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> builtins.str:
        return pulumi.get(self, "manifest_url")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> builtins.str:
        return pulumi.get(self, "node_command")

    @property
    @pulumi.getter
    def token(self) -> builtins.str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> builtins.str:
        return pulumi.get(self, "windows_node_command")


@pulumi.output_type
class GetClusterV2RkeConfigResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterV2RkeConfigEtcdResult',
                 machine_pool_defaults: Sequence['outputs.GetClusterV2RkeConfigMachinePoolDefaultResult'],
                 machine_pools: Sequence['outputs.GetClusterV2RkeConfigMachinePoolResult'],
                 machine_selector_configs: Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigResult'],
                 machine_selector_files: Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileResult'],
                 additional_manifest: Optional[builtins.str] = None,
                 chart_values: Optional[builtins.str] = None,
                 etcd_snapshot_create: Optional['outputs.GetClusterV2RkeConfigEtcdSnapshotCreateResult'] = None,
                 etcd_snapshot_restore: Optional['outputs.GetClusterV2RkeConfigEtcdSnapshotRestoreResult'] = None,
                 local_auth_endpoint: Optional['outputs.GetClusterV2RkeConfigLocalAuthEndpointResult'] = None,
                 machine_global_config: Optional[builtins.str] = None,
                 registries: Optional['outputs.GetClusterV2RkeConfigRegistriesResult'] = None,
                 rotate_certificates: Optional['outputs.GetClusterV2RkeConfigRotateCertificatesResult'] = None,
                 upgrade_strategy: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyResult'] = None):
        """
        :param 'GetClusterV2RkeConfigEtcdArgs' etcd: Cluster V2 etcd
        :param Sequence['GetClusterV2RkeConfigMachinePoolDefaultArgs'] machine_pool_defaults: Default values for machine pool configurations if unset
        :param Sequence['GetClusterV2RkeConfigMachinePoolArgs'] machine_pools: Cluster V2 machine pools
        :param Sequence['GetClusterV2RkeConfigMachineSelectorConfigArgs'] machine_selector_configs: Cluster V2 machine selector config
        :param Sequence['GetClusterV2RkeConfigMachineSelectorFileArgs'] machine_selector_files: Cluster V2 machine selector files
        :param builtins.str additional_manifest: Cluster V2 additional manifest
        :param builtins.str chart_values: Cluster V2 chart values. It should be in YAML format
        :param 'GetClusterV2RkeConfigEtcdSnapshotCreateArgs' etcd_snapshot_create: Cluster V2 etcd snapshot create
        :param 'GetClusterV2RkeConfigEtcdSnapshotRestoreArgs' etcd_snapshot_restore: Cluster V2 etcd snapshot restore
        :param 'GetClusterV2RkeConfigLocalAuthEndpointArgs' local_auth_endpoint: Cluster V2 local auth endpoint
        :param builtins.str machine_global_config: Cluster V2 machine global config
        :param 'GetClusterV2RkeConfigRegistriesArgs' registries: Cluster V2 registries
        :param 'GetClusterV2RkeConfigRotateCertificatesArgs' rotate_certificates: Cluster V2 certificate rotation
        :param 'GetClusterV2RkeConfigUpgradeStrategyArgs' upgrade_strategy: Cluster V2 upgrade strategy
        """
        pulumi.set(__self__, "etcd", etcd)
        pulumi.set(__self__, "machine_pool_defaults", machine_pool_defaults)
        pulumi.set(__self__, "machine_pools", machine_pools)
        pulumi.set(__self__, "machine_selector_configs", machine_selector_configs)
        pulumi.set(__self__, "machine_selector_files", machine_selector_files)
        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_snapshot_create is not None:
            pulumi.set(__self__, "etcd_snapshot_create", etcd_snapshot_create)
        if etcd_snapshot_restore is not None:
            pulumi.set(__self__, "etcd_snapshot_restore", etcd_snapshot_restore)
        if local_auth_endpoint is not None:
            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 rotate_certificates is not None:
            pulumi.set(__self__, "rotate_certificates", rotate_certificates)
        if upgrade_strategy is not None:
            pulumi.set(__self__, "upgrade_strategy", upgrade_strategy)

    @property
    @pulumi.getter
    def etcd(self) -> 'outputs.GetClusterV2RkeConfigEtcdResult':
        """
        Cluster V2 etcd
        """
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="machinePoolDefaults")
    def machine_pool_defaults(self) -> Sequence['outputs.GetClusterV2RkeConfigMachinePoolDefaultResult']:
        """
        Default values for machine pool configurations if unset
        """
        return pulumi.get(self, "machine_pool_defaults")

    @property
    @pulumi.getter(name="machinePools")
    def machine_pools(self) -> Sequence['outputs.GetClusterV2RkeConfigMachinePoolResult']:
        """
        Cluster V2 machine pools
        """
        return pulumi.get(self, "machine_pools")

    @property
    @pulumi.getter(name="machineSelectorConfigs")
    def machine_selector_configs(self) -> Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigResult']:
        """
        Cluster V2 machine selector config
        """
        return pulumi.get(self, "machine_selector_configs")

    @property
    @pulumi.getter(name="machineSelectorFiles")
    def machine_selector_files(self) -> Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileResult']:
        """
        Cluster V2 machine selector files
        """
        return pulumi.get(self, "machine_selector_files")

    @property
    @pulumi.getter(name="additionalManifest")
    def additional_manifest(self) -> Optional[builtins.str]:
        """
        Cluster V2 additional manifest
        """
        return pulumi.get(self, "additional_manifest")

    @property
    @pulumi.getter(name="chartValues")
    def chart_values(self) -> Optional[builtins.str]:
        """
        Cluster V2 chart values. It should be in YAML format
        """
        return pulumi.get(self, "chart_values")

    @property
    @pulumi.getter(name="etcdSnapshotCreate")
    def etcd_snapshot_create(self) -> Optional['outputs.GetClusterV2RkeConfigEtcdSnapshotCreateResult']:
        """
        Cluster V2 etcd snapshot create
        """
        return pulumi.get(self, "etcd_snapshot_create")

    @property
    @pulumi.getter(name="etcdSnapshotRestore")
    def etcd_snapshot_restore(self) -> Optional['outputs.GetClusterV2RkeConfigEtcdSnapshotRestoreResult']:
        """
        Cluster V2 etcd snapshot restore
        """
        return pulumi.get(self, "etcd_snapshot_restore")

    @property
    @pulumi.getter(name="localAuthEndpoint")
    @_utilities.deprecated("""Use rancher2_cluster_v2.local_auth_endpoint instead""")
    def local_auth_endpoint(self) -> Optional['outputs.GetClusterV2RkeConfigLocalAuthEndpointResult']:
        """
        Cluster V2 local auth endpoint
        """
        return pulumi.get(self, "local_auth_endpoint")

    @property
    @pulumi.getter(name="machineGlobalConfig")
    def machine_global_config(self) -> Optional[builtins.str]:
        """
        Cluster V2 machine global config
        """
        return pulumi.get(self, "machine_global_config")

    @property
    @pulumi.getter
    def registries(self) -> Optional['outputs.GetClusterV2RkeConfigRegistriesResult']:
        """
        Cluster V2 registries
        """
        return pulumi.get(self, "registries")

    @property
    @pulumi.getter(name="rotateCertificates")
    def rotate_certificates(self) -> Optional['outputs.GetClusterV2RkeConfigRotateCertificatesResult']:
        """
        Cluster V2 certificate rotation
        """
        return pulumi.get(self, "rotate_certificates")

    @property
    @pulumi.getter(name="upgradeStrategy")
    def upgrade_strategy(self) -> Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyResult']:
        """
        Cluster V2 upgrade strategy
        """
        return pulumi.get(self, "upgrade_strategy")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdResult(dict):
    def __init__(__self__, *,
                 disable_snapshots: Optional[builtins.bool] = None,
                 s3_config: Optional['outputs.GetClusterV2RkeConfigEtcdS3ConfigResult'] = None,
                 snapshot_retention: Optional[builtins.int] = None,
                 snapshot_schedule_cron: Optional[builtins.str] = None):
        """
        :param builtins.bool disable_snapshots: Disable ETCD snapshots
        :param 'GetClusterV2RkeConfigEtcdS3ConfigArgs' s3_config: ETCD snapshot S3 config
        :param builtins.int snapshot_retention: ETCD snapshot retention
        :param builtins.str snapshot_schedule_cron: ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        if disable_snapshots is not None:
            pulumi.set(__self__, "disable_snapshots", disable_snapshots)
        if s3_config is not None:
            pulumi.set(__self__, "s3_config", s3_config)
        if snapshot_retention is not None:
            pulumi.set(__self__, "snapshot_retention", snapshot_retention)
        if snapshot_schedule_cron is not None:
            pulumi.set(__self__, "snapshot_schedule_cron", snapshot_schedule_cron)

    @property
    @pulumi.getter(name="disableSnapshots")
    def disable_snapshots(self) -> Optional[builtins.bool]:
        """
        Disable ETCD snapshots
        """
        return pulumi.get(self, "disable_snapshots")

    @property
    @pulumi.getter(name="s3Config")
    def s3_config(self) -> Optional['outputs.GetClusterV2RkeConfigEtcdS3ConfigResult']:
        """
        ETCD snapshot S3 config
        """
        return pulumi.get(self, "s3_config")

    @property
    @pulumi.getter(name="snapshotRetention")
    def snapshot_retention(self) -> Optional[builtins.int]:
        """
        ETCD snapshot retention
        """
        return pulumi.get(self, "snapshot_retention")

    @property
    @pulumi.getter(name="snapshotScheduleCron")
    def snapshot_schedule_cron(self) -> Optional[builtins.str]:
        """
        ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        return pulumi.get(self, "snapshot_schedule_cron")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdS3ConfigResult(dict):
    def __init__(__self__, *,
                 bucket: builtins.str,
                 endpoint: builtins.str,
                 cloud_credential_name: Optional[builtins.str] = None,
                 endpoint_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 skip_ssl_verify: Optional[builtins.bool] = None):
        """
        :param builtins.str bucket: ETCD snapshot S3 bucket
        :param builtins.str endpoint: ETCD snapshot S3 endpoint
        :param builtins.str cloud_credential_name: ETCD snapshot S3 cloud credential name
        :param builtins.str endpoint_ca: ETCD snapshot S3 endpoint CA
        :param builtins.str folder: ETCD snapshot S3 folder
        :param builtins.str region: ETCD snapshot S3 region
        :param builtins.bool skip_ssl_verify: Disable ETCD skip ssl verify
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "endpoint", endpoint)
        if cloud_credential_name is not None:
            pulumi.set(__self__, "cloud_credential_name", cloud_credential_name)
        if endpoint_ca is not None:
            pulumi.set(__self__, "endpoint_ca", endpoint_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if skip_ssl_verify is not None:
            pulumi.set(__self__, "skip_ssl_verify", skip_ssl_verify)

    @property
    @pulumi.getter
    def bucket(self) -> builtins.str:
        """
        ETCD snapshot S3 bucket
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def endpoint(self) -> builtins.str:
        """
        ETCD snapshot S3 endpoint
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="cloudCredentialName")
    def cloud_credential_name(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 cloud credential name
        """
        return pulumi.get(self, "cloud_credential_name")

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 endpoint CA
        """
        return pulumi.get(self, "endpoint_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 folder
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        """
        ETCD snapshot S3 region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[builtins.bool]:
        """
        Disable ETCD skip ssl verify
        """
        return pulumi.get(self, "skip_ssl_verify")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdSnapshotCreateResult(dict):
    def __init__(__self__, *,
                 generation: builtins.int):
        """
        :param builtins.int generation: ETCD generation to initiate a snapshot
        """
        pulumi.set(__self__, "generation", generation)

    @property
    @pulumi.getter
    def generation(self) -> builtins.int:
        """
        ETCD generation to initiate a snapshot
        """
        return pulumi.get(self, "generation")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdSnapshotRestoreResult(dict):
    def __init__(__self__, *,
                 generation: builtins.int,
                 name: builtins.str,
                 restore_rke_config: Optional[builtins.str] = None):
        """
        :param builtins.int generation: ETCD snapshot desired generation
        :param builtins.str name: The name of the Cluster v2 (string)
        :param builtins.str restore_rke_config: ETCD restore RKE config (set to none, all, or kubernetesVersion)
        """
        pulumi.set(__self__, "generation", generation)
        pulumi.set(__self__, "name", name)
        if restore_rke_config is not None:
            pulumi.set(__self__, "restore_rke_config", restore_rke_config)

    @property
    @pulumi.getter
    def generation(self) -> builtins.int:
        """
        ETCD snapshot desired generation
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="restoreRkeConfig")
    def restore_rke_config(self) -> Optional[builtins.str]:
        """
        ETCD restore RKE config (set to none, all, or kubernetesVersion)
        """
        return pulumi.get(self, "restore_rke_config")


@pulumi.output_type
class GetClusterV2RkeConfigLocalAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 fqdn: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[builtins.str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, builtins.str],
                 labels: Mapping[str, builtins.str],
                 machine_config: 'outputs.GetClusterV2RkeConfigMachinePoolMachineConfigResult',
                 machine_labels: Mapping[str, builtins.str],
                 name: builtins.str,
                 cloud_credential_secret_name: Optional[builtins.str] = None,
                 control_plane_role: Optional[builtins.bool] = None,
                 drain_before_delete: Optional[builtins.bool] = None,
                 etcd_role: Optional[builtins.bool] = None,
                 hostname_length_limit: Optional[builtins.int] = None,
                 max_unhealthy: Optional[builtins.str] = None,
                 node_drain_timeout: Optional[builtins.int] = None,
                 node_startup_timeout_seconds: Optional[builtins.int] = None,
                 paused: Optional[builtins.bool] = None,
                 quantity: Optional[builtins.int] = None,
                 rolling_update: Optional['outputs.GetClusterV2RkeConfigMachinePoolRollingUpdateResult'] = None,
                 taints: Optional[Sequence['outputs.GetClusterV2RkeConfigMachinePoolTaintResult']] = None,
                 unhealthy_node_timeout_seconds: Optional[builtins.int] = None,
                 unhealthy_range: Optional[builtins.str] = None,
                 worker_role: Optional[builtins.bool] = None):
        """
        :param Mapping[str, builtins.str] annotations: Annotations of the resource
        :param Mapping[str, builtins.str] labels: Labels of the resource
        :param 'GetClusterV2RkeConfigMachinePoolMachineConfigArgs' machine_config: Machine config data
        :param Mapping[str, builtins.str] machine_labels: Labels of the machine
        :param builtins.str name: The name of the Cluster v2 (string)
        :param builtins.str cloud_credential_secret_name: (Computed) Cluster V2 cloud credential secret name (string)
        :param builtins.bool control_plane_role: Machine pool control plane role
        :param builtins.bool drain_before_delete: Machine pool drain before delete
        :param builtins.bool etcd_role: Machine pool etcd role
        :param builtins.int hostname_length_limit: maximum length for autogenerated hostname
        :param builtins.str max_unhealthy: max unhealthy nodes for automated replacement to be allowed
        :param builtins.int node_drain_timeout: seconds to wait for machine pool drain to complete before machine deletion
        :param builtins.int node_startup_timeout_seconds: seconds a new node has to become active before it is replaced
        :param builtins.bool paused: Machine pool paused
        :param builtins.int quantity: Machine pool quantity
        :param 'GetClusterV2RkeConfigMachinePoolRollingUpdateArgs' rolling_update: Machine pool rolling update
        :param Sequence['GetClusterV2RkeConfigMachinePoolTaintArgs'] taints: Machine pool taints
        :param builtins.int unhealthy_node_timeout_seconds: seconds an unhealthy node has to become active before it is replaced
        :param builtins.str unhealthy_range: range of unhealthy nodes for automated replacement to be allowed
        :param builtins.bool worker_role: Machine pool worker role
        """
        pulumi.set(__self__, "annotations", annotations)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "machine_config", machine_config)
        pulumi.set(__self__, "machine_labels", machine_labels)
        pulumi.set(__self__, "name", name)
        if cloud_credential_secret_name is not None:
            pulumi.set(__self__, "cloud_credential_secret_name", cloud_credential_secret_name)
        if control_plane_role is not None:
            pulumi.set(__self__, "control_plane_role", control_plane_role)
        if drain_before_delete is not None:
            pulumi.set(__self__, "drain_before_delete", drain_before_delete)
        if etcd_role is not None:
            pulumi.set(__self__, "etcd_role", etcd_role)
        if hostname_length_limit is not None:
            pulumi.set(__self__, "hostname_length_limit", hostname_length_limit)
        if max_unhealthy is not None:
            pulumi.set(__self__, "max_unhealthy", max_unhealthy)
        if node_drain_timeout is not None:
            pulumi.set(__self__, "node_drain_timeout", node_drain_timeout)
        if node_startup_timeout_seconds is not None:
            pulumi.set(__self__, "node_startup_timeout_seconds", node_startup_timeout_seconds)
        if paused is not None:
            pulumi.set(__self__, "paused", paused)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if unhealthy_node_timeout_seconds is not None:
            pulumi.set(__self__, "unhealthy_node_timeout_seconds", unhealthy_node_timeout_seconds)
        if unhealthy_range is not None:
            pulumi.set(__self__, "unhealthy_range", unhealthy_range)
        if worker_role is not None:
            pulumi.set(__self__, "worker_role", worker_role)

    @property
    @pulumi.getter
    def annotations(self) -> Mapping[str, builtins.str]:
        """
        Annotations of the resource
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, builtins.str]:
        """
        Labels of the resource
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="machineConfig")
    def machine_config(self) -> 'outputs.GetClusterV2RkeConfigMachinePoolMachineConfigResult':
        """
        Machine config data
        """
        return pulumi.get(self, "machine_config")

    @property
    @pulumi.getter(name="machineLabels")
    def machine_labels(self) -> Mapping[str, builtins.str]:
        """
        Labels of the machine
        """
        return pulumi.get(self, "machine_labels")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="cloudCredentialSecretName")
    def cloud_credential_secret_name(self) -> Optional[builtins.str]:
        """
        (Computed) Cluster V2 cloud credential secret name (string)
        """
        return pulumi.get(self, "cloud_credential_secret_name")

    @property
    @pulumi.getter(name="controlPlaneRole")
    def control_plane_role(self) -> Optional[builtins.bool]:
        """
        Machine pool control plane role
        """
        return pulumi.get(self, "control_plane_role")

    @property
    @pulumi.getter(name="drainBeforeDelete")
    def drain_before_delete(self) -> Optional[builtins.bool]:
        """
        Machine pool drain before delete
        """
        return pulumi.get(self, "drain_before_delete")

    @property
    @pulumi.getter(name="etcdRole")
    def etcd_role(self) -> Optional[builtins.bool]:
        """
        Machine pool etcd role
        """
        return pulumi.get(self, "etcd_role")

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[builtins.int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")

    @property
    @pulumi.getter(name="maxUnhealthy")
    def max_unhealthy(self) -> Optional[builtins.str]:
        """
        max unhealthy nodes for automated replacement to be allowed
        """
        return pulumi.get(self, "max_unhealthy")

    @property
    @pulumi.getter(name="nodeDrainTimeout")
    def node_drain_timeout(self) -> Optional[builtins.int]:
        """
        seconds to wait for machine pool drain to complete before machine deletion
        """
        return pulumi.get(self, "node_drain_timeout")

    @property
    @pulumi.getter(name="nodeStartupTimeoutSeconds")
    def node_startup_timeout_seconds(self) -> Optional[builtins.int]:
        """
        seconds a new node has to become active before it is replaced
        """
        return pulumi.get(self, "node_startup_timeout_seconds")

    @property
    @pulumi.getter
    def paused(self) -> Optional[builtins.bool]:
        """
        Machine pool paused
        """
        return pulumi.get(self, "paused")

    @property
    @pulumi.getter
    def quantity(self) -> Optional[builtins.int]:
        """
        Machine pool quantity
        """
        return pulumi.get(self, "quantity")

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetClusterV2RkeConfigMachinePoolRollingUpdateResult']:
        """
        Machine pool rolling update
        """
        return pulumi.get(self, "rolling_update")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachinePoolTaintResult']]:
        """
        Machine pool taints
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="unhealthyNodeTimeoutSeconds")
    def unhealthy_node_timeout_seconds(self) -> Optional[builtins.int]:
        """
        seconds an unhealthy node has to become active before it is replaced
        """
        return pulumi.get(self, "unhealthy_node_timeout_seconds")

    @property
    @pulumi.getter(name="unhealthyRange")
    def unhealthy_range(self) -> Optional[builtins.str]:
        """
        range of unhealthy nodes for automated replacement to be allowed
        """
        return pulumi.get(self, "unhealthy_range")

    @property
    @pulumi.getter(name="workerRole")
    def worker_role(self) -> Optional[builtins.bool]:
        """
        Machine pool worker role
        """
        return pulumi.get(self, "worker_role")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolDefaultResult(dict):
    def __init__(__self__, *,
                 hostname_length_limit: Optional[builtins.int] = None):
        """
        :param builtins.int hostname_length_limit: maximum length for autogenerated hostname
        """
        if hostname_length_limit is not None:
            pulumi.set(__self__, "hostname_length_limit", hostname_length_limit)

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[builtins.int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolMachineConfigResult(dict):
    def __init__(__self__, *,
                 kind: builtins.str,
                 name: builtins.str,
                 api_version: Optional[builtins.str] = None):
        """
        :param builtins.str kind: Machine config kind
        :param builtins.str name: The name of the Cluster v2 (string)
        :param builtins.str api_version: Machine config API version
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "name", name)
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)

    @property
    @pulumi.getter
    def kind(self) -> builtins.str:
        """
        Machine config kind
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[builtins.str]:
        """
        Machine config API version
        """
        return pulumi.get(self, "api_version")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[builtins.str] = None,
                 max_unavailable: Optional[builtins.str] = None):
        """
        :param builtins.str max_surge: Rolling update max surge
        :param builtins.str max_unavailable: Rolling update max unavailable
        """
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[builtins.str]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[builtins.str]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolTaintResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str,
                 effect: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorConfigResult(dict):
    def __init__(__self__, *,
                 config: Optional[builtins.str] = None,
                 machine_label_selector: Optional['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult'] = None):
        """
        :param builtins.str config: Machine selector config
        :param 'GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorArgs' machine_label_selector: Machine label selector
        """
        if config is not None:
            pulumi.set(__self__, "config", config)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

    @property
    @pulumi.getter
    def config(self) -> Optional[builtins.str]:
        """
        Machine selector config
        """
        return pulumi.get(self, "config")

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult']:
        """
        Machine label selector
        """
        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, builtins.str]] = None):
        """
        :param Sequence['GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, builtins.str] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult']]:
        """
        Label selector match expressions
        """
        return pulumi.get(self, "match_expressions")

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 values: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.str key: Label selector requirement key
        :param builtins.str operator: Label selector operator
        :param Sequence[builtins.str] values: Label selector requirement values
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[builtins.str]]:
        """
        Label selector requirement values
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileResult(dict):
    def __init__(__self__, *,
                 file_sources: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceResult']] = None,
                 machine_label_selector: Optional['outputs.GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorResult'] = None):
        """
        :param Sequence['GetClusterV2RkeConfigMachineSelectorFileFileSourceArgs'] file_sources: File sources
        :param 'GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorArgs' machine_label_selector: Machine label selector
        """
        if file_sources is not None:
            pulumi.set(__self__, "file_sources", file_sources)
        if machine_label_selector is not None:
            pulumi.set(__self__, "machine_label_selector", machine_label_selector)

    @property
    @pulumi.getter(name="fileSources")
    def file_sources(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceResult']]:
        """
        File sources
        """
        return pulumi.get(self, "file_sources")

    @property
    @pulumi.getter(name="machineLabelSelector")
    def machine_label_selector(self) -> Optional['outputs.GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorResult']:
        """
        Machine label selector
        """
        return pulumi.get(self, "machine_label_selector")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileFileSourceResult(dict):
    def __init__(__self__, *,
                 configmap: Optional['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapResult'] = None,
                 secret: Optional['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretResult'] = None):
        """
        :param 'GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapArgs' configmap: The configmap which is the source of files
        :param 'GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretArgs' secret: The secret which is the source of files
        """
        if configmap is not None:
            pulumi.set(__self__, "configmap", configmap)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def configmap(self) -> Optional['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapResult']:
        """
        The configmap which is the source of files
        """
        return pulumi.get(self, "configmap")

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretResult']:
        """
        The secret which is the source of files
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 default_permissions: Optional[builtins.str] = None,
                 items: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemResult']] = None):
        """
        :param builtins.str name: The name of the Cluster v2 (string)
        :param builtins.str default_permissions: The default permissions to be applied when they are not set at the item level
        :param Sequence['GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemArgs'] items: Items(files) to retrieve from the K8s object
        """
        pulumi.set(__self__, "name", name)
        if default_permissions is not None:
            pulumi.set(__self__, "default_permissions", default_permissions)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[builtins.str]:
        """
        The default permissions to be applied when they are not set at the item level
        """
        return pulumi.get(self, "default_permissions")

    @property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemResult']]:
        """
        Items(files) to retrieve from the K8s object
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 path: builtins.str,
                 dynamic: Optional[builtins.bool] = None,
                 hash: Optional[builtins.str] = None,
                 permissions: Optional[builtins.str] = None):
        """
        :param builtins.str key: The key of the item(file) to retrieve
        :param builtins.str path: The path to put the file in the target node
        :param builtins.bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param builtins.str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param builtins.str permissions: The numeric representation of the file permissions
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        if dynamic is not None:
            pulumi.set(__self__, "dynamic", dynamic)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[builtins.bool]:
        """
        If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        """
        return pulumi.get(self, "dynamic")

    @property
    @pulumi.getter
    def hash(self) -> Optional[builtins.str]:
        """
        The base64 encoded value of the SHA256 checksum of the file's content
        """
        return pulumi.get(self, "hash")

    @property
    @pulumi.getter
    def permissions(self) -> Optional[builtins.str]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 default_permissions: Optional[builtins.str] = None,
                 items: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemResult']] = None):
        """
        :param builtins.str name: The name of the Cluster v2 (string)
        :param builtins.str default_permissions: The default permissions to be applied when they are not set at the item level
        :param Sequence['GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemArgs'] items: Items(files) to retrieve from the K8s object
        """
        pulumi.set(__self__, "name", name)
        if default_permissions is not None:
            pulumi.set(__self__, "default_permissions", default_permissions)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[builtins.str]:
        """
        The default permissions to be applied when they are not set at the item level
        """
        return pulumi.get(self, "default_permissions")

    @property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemResult']]:
        """
        Items(files) to retrieve from the K8s object
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 path: builtins.str,
                 dynamic: Optional[builtins.bool] = None,
                 hash: Optional[builtins.str] = None,
                 permissions: Optional[builtins.str] = None):
        """
        :param builtins.str key: The key of the item(file) to retrieve
        :param builtins.str path: The path to put the file in the target node
        :param builtins.bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param builtins.str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param builtins.str permissions: The numeric representation of the file permissions
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        if dynamic is not None:
            pulumi.set(__self__, "dynamic", dynamic)
        if hash is not None:
            pulumi.set(__self__, "hash", hash)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[builtins.bool]:
        """
        If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        """
        return pulumi.get(self, "dynamic")

    @property
    @pulumi.getter
    def hash(self) -> Optional[builtins.str]:
        """
        The base64 encoded value of the SHA256 checksum of the file's content
        """
        return pulumi.get(self, "hash")

    @property
    @pulumi.getter
    def permissions(self) -> Optional[builtins.str]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorResult(dict):
    def __init__(__self__, *,
                 match_expressions: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionResult']] = None,
                 match_labels: Optional[Mapping[str, builtins.str]] = None):
        """
        :param Sequence['GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, builtins.str] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionResult']]:
        """
        Label selector match expressions
        """
        return pulumi.get(self, "match_expressions")

    @property
    @pulumi.getter(name="matchLabels")
    def match_labels(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionResult(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None,
                 values: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.str key: Label selector requirement key
        :param builtins.str operator: Label selector operator
        :param Sequence[builtins.str] values: Label selector requirement values
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[builtins.str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[builtins.str]]:
        """
        Label selector requirement values
        """
        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):
        """
        :param Sequence['GetClusterV2RkeConfigRegistriesConfigArgs'] configs: Registry config
        :param Sequence['GetClusterV2RkeConfigRegistriesMirrorArgs'] mirrors: Registry mirrors
        """
        if configs is not None:
            pulumi.set(__self__, "configs", configs)
        if mirrors is not None:
            pulumi.set(__self__, "mirrors", mirrors)

    @property
    @pulumi.getter
    def configs(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigRegistriesConfigResult']]:
        """
        Registry config
        """
        return pulumi.get(self, "configs")

    @property
    @pulumi.getter
    def mirrors(self) -> Optional[Sequence['outputs.GetClusterV2RkeConfigRegistriesMirrorResult']]:
        """
        Registry mirrors
        """
        return pulumi.get(self, "mirrors")


@pulumi.output_type
class GetClusterV2RkeConfigRegistriesConfigResult(dict):
    def __init__(__self__, *,
                 hostname: builtins.str,
                 auth_config_secret_name: Optional[builtins.str] = None,
                 ca_bundle: Optional[builtins.str] = None,
                 insecure: Optional[builtins.bool] = None,
                 tls_secret_name: Optional[builtins.str] = None):
        """
        :param builtins.str hostname: Registry hostname
        :param builtins.str auth_config_secret_name: Registry auth config secret name
        :param builtins.str ca_bundle: Registry CA bundle
        :param builtins.bool insecure: Registry insecure connectivity
        :param builtins.str tls_secret_name: Registry TLS secret name. TLS is a pair of Cert/Key
        """
        pulumi.set(__self__, "hostname", hostname)
        if auth_config_secret_name is not None:
            pulumi.set(__self__, "auth_config_secret_name", auth_config_secret_name)
        if ca_bundle is not None:
            pulumi.set(__self__, "ca_bundle", ca_bundle)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if tls_secret_name is not None:
            pulumi.set(__self__, "tls_secret_name", tls_secret_name)

    @property
    @pulumi.getter
    def hostname(self) -> builtins.str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter(name="authConfigSecretName")
    def auth_config_secret_name(self) -> Optional[builtins.str]:
        """
        Registry auth config secret name
        """
        return pulumi.get(self, "auth_config_secret_name")

    @property
    @pulumi.getter(name="caBundle")
    def ca_bundle(self) -> Optional[builtins.str]:
        """
        Registry CA bundle
        """
        return pulumi.get(self, "ca_bundle")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[builtins.bool]:
        """
        Registry insecure connectivity
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="tlsSecretName")
    def tls_secret_name(self) -> Optional[builtins.str]:
        """
        Registry TLS secret name. TLS is a pair of Cert/Key
        """
        return pulumi.get(self, "tls_secret_name")


@pulumi.output_type
class GetClusterV2RkeConfigRegistriesMirrorResult(dict):
    def __init__(__self__, *,
                 hostname: builtins.str,
                 endpoints: Optional[Sequence[builtins.str]] = None,
                 rewrites: Optional[Mapping[str, builtins.str]] = None):
        """
        :param builtins.str hostname: Registry hostname
        :param Sequence[builtins.str] endpoints: Registry mirror endpoints
        :param Mapping[str, builtins.str] rewrites: Registry mirror rewrites
        """
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

    @property
    @pulumi.getter
    def hostname(self) -> builtins.str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[Sequence[builtins.str]]:
        """
        Registry mirror endpoints
        """
        return pulumi.get(self, "endpoints")

    @property
    @pulumi.getter
    def rewrites(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Registry mirror rewrites
        """
        return pulumi.get(self, "rewrites")


@pulumi.output_type
class GetClusterV2RkeConfigRotateCertificatesResult(dict):
    def __init__(__self__, *,
                 generation: builtins.int,
                 services: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.int generation: Desired certificate rotation generation.
        :param Sequence[builtins.str] services: Service certificates to rotate with this generation.
        """
        pulumi.set(__self__, "generation", generation)
        if services is not None:
            pulumi.set(__self__, "services", services)

    @property
    @pulumi.getter
    def generation(self) -> builtins.int:
        """
        Desired certificate rotation generation.
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def services(self) -> Optional[Sequence[builtins.str]]:
        """
        Service certificates to rotate with this generation.
        """
        return pulumi.get(self, "services")


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 control_plane_concurrency: Optional[builtins.str] = None,
                 control_plane_drain_options: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult'] = None,
                 worker_concurrency: Optional[builtins.str] = None,
                 worker_drain_options: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult'] = None):
        """
        :param builtins.str control_plane_concurrency: How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        :param 'GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs' control_plane_drain_options: Controlplane nodes drain options
        :param builtins.str worker_concurrency: How many worker nodes should be upgrade at time
        :param 'GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsArgs' worker_drain_options: Worker nodes drain options
        """
        if control_plane_concurrency is not None:
            pulumi.set(__self__, "control_plane_concurrency", control_plane_concurrency)
        if control_plane_drain_options is not None:
            pulumi.set(__self__, "control_plane_drain_options", control_plane_drain_options)
        if worker_concurrency is not None:
            pulumi.set(__self__, "worker_concurrency", worker_concurrency)
        if worker_drain_options is not None:
            pulumi.set(__self__, "worker_drain_options", worker_drain_options)

    @property
    @pulumi.getter(name="controlPlaneConcurrency")
    def control_plane_concurrency(self) -> Optional[builtins.str]:
        """
        How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        """
        return pulumi.get(self, "control_plane_concurrency")

    @property
    @pulumi.getter(name="controlPlaneDrainOptions")
    def control_plane_drain_options(self) -> Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult']:
        """
        Controlplane nodes drain options
        """
        return pulumi.get(self, "control_plane_drain_options")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[builtins.str]:
        """
        How many worker nodes should be upgrade at time
        """
        return pulumi.get(self, "worker_concurrency")

    @property
    @pulumi.getter(name="workerDrainOptions")
    def worker_drain_options(self) -> Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult']:
        """
        Worker nodes drain options
        """
        return pulumi.get(self, "worker_drain_options")


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult(dict):
    def __init__(__self__, *,
                 grace_period: builtins.int,
                 skip_wait_for_delete_timeout_seconds: builtins.int,
                 timeout: builtins.int,
                 delete_empty_dir_data: Optional[builtins.bool] = None,
                 disable_eviction: Optional[builtins.bool] = None,
                 enabled: Optional[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 ignore_errors: Optional[builtins.bool] = None):
        """
        :param builtins.int grace_period: Drain options grace period
        :param builtins.int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param builtins.int timeout: Drain options timeout
        :param builtins.bool delete_empty_dir_data: Drain options delete empty dir data
        :param builtins.bool disable_eviction: Drain options disable eviction
        :param builtins.bool enabled: Drain options enabled?
        :param builtins.bool force: Drain options force
        :param builtins.bool ignore_daemon_sets: Drain options ignore daemon sets
        :param builtins.bool ignore_errors: Drain options ignore errors
        """
        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) -> builtins.int:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> builtins.int:
        """
        Drain options skip wait for delete timeout seconds
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

    @property
    @pulumi.getter
    def timeout(self) -> builtins.int:
        """
        Drain options timeout
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[builtins.bool]:
        """
        Drain options delete empty dir data
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[builtins.bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[builtins.bool]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult(dict):
    def __init__(__self__, *,
                 grace_period: builtins.int,
                 skip_wait_for_delete_timeout_seconds: builtins.int,
                 timeout: builtins.int,
                 delete_empty_dir_data: Optional[builtins.bool] = None,
                 disable_eviction: Optional[builtins.bool] = None,
                 enabled: Optional[builtins.bool] = None,
                 force: Optional[builtins.bool] = None,
                 ignore_daemon_sets: Optional[builtins.bool] = None,
                 ignore_errors: Optional[builtins.bool] = None):
        """
        :param builtins.int grace_period: Drain options grace period
        :param builtins.int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param builtins.int timeout: Drain options timeout
        :param builtins.bool delete_empty_dir_data: Drain options delete empty dir data
        :param builtins.bool disable_eviction: Drain options disable eviction
        :param builtins.bool enabled: Drain options enabled?
        :param builtins.bool force: Drain options force
        :param builtins.bool ignore_daemon_sets: Drain options ignore daemon sets
        :param builtins.bool ignore_errors: Drain options ignore errors
        """
        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) -> builtins.int:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> builtins.int:
        """
        Drain options skip wait for delete timeout seconds
        """
        return pulumi.get(self, "skip_wait_for_delete_timeout_seconds")

    @property
    @pulumi.getter
    def timeout(self) -> builtins.int:
        """
        Drain options timeout
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[builtins.bool]:
        """
        Drain options delete empty dir data
        """
        return pulumi.get(self, "delete_empty_dir_data")

    @property
    @pulumi.getter(name="disableEviction")
    def disable_eviction(self) -> Optional[builtins.bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[builtins.bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[builtins.bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[builtins.bool]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")


@pulumi.output_type
class GetEtcdBackupBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: builtins.int,
                 enabled: Optional[builtins.bool] = None,
                 interval_hours: Optional[builtins.int] = None,
                 retention: Optional[builtins.int] = None,
                 s3_backup_config: Optional['outputs.GetEtcdBackupBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[builtins.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) -> builtins.int:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[builtins.int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[builtins.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[builtins.bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetEtcdBackupBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: builtins.str,
                 endpoint: builtins.str,
                 access_key: Optional[builtins.str] = None,
                 custom_ca: Optional[builtins.str] = None,
                 folder: Optional[builtins.str] = None,
                 region: Optional[builtins.str] = None,
                 secret_key: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> builtins.str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[builtins.str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[builtins.str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[builtins.str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[builtins.str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetGlobalRoleRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[builtins.str]] = None,
                 non_resource_urls: Optional[Sequence[builtins.str]] = None,
                 resource_names: Optional[Sequence[builtins.str]] = None,
                 resources: Optional[Sequence[builtins.str]] = None,
                 verbs: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] api_groups: Policy rule api groups
        :param Sequence[builtins.str] non_resource_urls: Policy rule non resource urls
        :param Sequence[builtins.str] resource_names: Policy rule resource names
        :param Sequence[builtins.str] resources: Policy rule resources
        :param Sequence[builtins.str] verbs: Policy rule verbs
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetNamespaceContainerResourceLimitResult(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.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[builtins.str] = None,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 persistent_volume_claims: Optional[builtins.str] = None,
                 pods: Optional[builtins.str] = None,
                 replication_controllers: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None,
                 requests_storage: Optional[builtins.str] = None,
                 secrets: Optional[builtins.str] = None,
                 services: Optional[builtins.str] = None,
                 services_load_balancers: Optional[builtins.str] = None,
                 services_node_ports: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[builtins.str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[builtins.str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[builtins.str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetNodePoolNodeTaintResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 time_added: builtins.str,
                 value: builtins.str,
                 effect: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> builtins.str:
        return pulumi.get(self, "time_added")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetNodeTemplateNodeTaintResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 time_added: builtins.str,
                 value: builtins.str,
                 effect: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> builtins.str:
        return pulumi.get(self, "time_added")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[builtins.str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetPodSecurityAdmissionConfigurationTemplateDefaultsResult(dict):
    def __init__(__self__, *,
                 audit: Optional[builtins.str] = None,
                 audit_version: Optional[builtins.str] = None,
                 enforce: Optional[builtins.str] = None,
                 enforce_version: Optional[builtins.str] = None,
                 warn: Optional[builtins.str] = None,
                 warn_version: Optional[builtins.str] = None):
        """
        :param builtins.str audit: Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param builtins.str audit_version: Pod Security Admission Configuration audit version (default: latest)
        :param builtins.str enforce: Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param builtins.str enforce_version: Pod Security Admission Configuration enforce version (default: latest)
        :param builtins.str warn: Pod Security Admission Configuration warn. This warns the user about a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param builtins.str warn_version: Pod Security Admission Configuration warn version (default: latest)
        """
        if audit is not None:
            pulumi.set(__self__, "audit", audit)
        if audit_version is not None:
            pulumi.set(__self__, "audit_version", audit_version)
        if enforce is not None:
            pulumi.set(__self__, "enforce", enforce)
        if enforce_version is not None:
            pulumi.set(__self__, "enforce_version", enforce_version)
        if warn is not None:
            pulumi.set(__self__, "warn", warn)
        if warn_version is not None:
            pulumi.set(__self__, "warn_version", warn_version)

    @property
    @pulumi.getter
    def audit(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "audit")

    @property
    @pulumi.getter(name="auditVersion")
    def audit_version(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration audit version (default: latest)
        """
        return pulumi.get(self, "audit_version")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter(name="enforceVersion")
    def enforce_version(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration enforce version (default: latest)
        """
        return pulumi.get(self, "enforce_version")

    @property
    @pulumi.getter
    def warn(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration warn. This warns the user about a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        """
        return pulumi.get(self, "warn")

    @property
    @pulumi.getter(name="warnVersion")
    def warn_version(self) -> Optional[builtins.str]:
        """
        Pod Security Admission Configuration warn version (default: latest)
        """
        return pulumi.get(self, "warn_version")


@pulumi.output_type
class GetPodSecurityAdmissionConfigurationTemplateExemptionsResult(dict):
    def __init__(__self__, *,
                 namespaces: Optional[Sequence[builtins.str]] = None,
                 runtime_classes: Optional[Sequence[builtins.str]] = None,
                 usernames: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] namespaces: Pod Security Admission Configuration namespace exemptions
        :param Sequence[builtins.str] runtime_classes: Pod Security Admission Configuration runtime class exemptions
        :param Sequence[builtins.str] usernames: Pod Security Admission Configuration username exemptions
        """
        if namespaces is not None:
            pulumi.set(__self__, "namespaces", namespaces)
        if runtime_classes is not None:
            pulumi.set(__self__, "runtime_classes", runtime_classes)
        if usernames is not None:
            pulumi.set(__self__, "usernames", usernames)

    @property
    @pulumi.getter
    def namespaces(self) -> Optional[Sequence[builtins.str]]:
        """
        Pod Security Admission Configuration namespace exemptions
        """
        return pulumi.get(self, "namespaces")

    @property
    @pulumi.getter(name="runtimeClasses")
    def runtime_classes(self) -> Optional[Sequence[builtins.str]]:
        """
        Pod Security Admission Configuration runtime class exemptions
        """
        return pulumi.get(self, "runtime_classes")

    @property
    @pulumi.getter
    def usernames(self) -> Optional[Sequence[builtins.str]]:
        """
        Pod Security Admission Configuration username exemptions
        """
        return pulumi.get(self, "usernames")


@pulumi.output_type
class GetProjectContainerResourceLimitResult(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_memory")


@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[builtins.str] = None,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 persistent_volume_claims: Optional[builtins.str] = None,
                 pods: Optional[builtins.str] = None,
                 replication_controllers: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None,
                 requests_storage: Optional[builtins.str] = None,
                 secrets: Optional[builtins.str] = None,
                 services: Optional[builtins.str] = None,
                 services_load_balancers: Optional[builtins.str] = None,
                 services_node_ports: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[builtins.str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[builtins.str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[builtins.str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetProjectResourceQuotaProjectLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[builtins.str] = None,
                 limits_cpu: Optional[builtins.str] = None,
                 limits_memory: Optional[builtins.str] = None,
                 persistent_volume_claims: Optional[builtins.str] = None,
                 pods: Optional[builtins.str] = None,
                 replication_controllers: Optional[builtins.str] = None,
                 requests_cpu: Optional[builtins.str] = None,
                 requests_memory: Optional[builtins.str] = None,
                 requests_storage: Optional[builtins.str] = None,
                 secrets: Optional[builtins.str] = None,
                 services: Optional[builtins.str] = None,
                 services_load_balancers: Optional[builtins.str] = None,
                 services_node_ports: Optional[builtins.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[builtins.str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[builtins.str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[builtins.str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[builtins.str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[builtins.str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[builtins.str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[builtins.str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetRegistryRegistryResult(dict):
    def __init__(__self__, *,
                 address: builtins.str,
                 password: Optional[builtins.str] = None,
                 username: Optional[builtins.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) -> builtins.str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[builtins.str]:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetRoleTemplateExternalRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[builtins.str]] = None,
                 non_resource_urls: Optional[Sequence[builtins.str]] = None,
                 resource_names: Optional[Sequence[builtins.str]] = None,
                 resources: Optional[Sequence[builtins.str]] = None,
                 verbs: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] api_groups: Policy rule api groups
        :param Sequence[builtins.str] non_resource_urls: Policy rule non resource urls
        :param Sequence[builtins.str] resource_names: Policy rule resource names
        :param Sequence[builtins.str] resources: Policy rule resources
        :param Sequence[builtins.str] verbs: Policy rule verbs
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetRoleTemplateRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[builtins.str]] = None,
                 non_resource_urls: Optional[Sequence[builtins.str]] = None,
                 resource_names: Optional[Sequence[builtins.str]] = None,
                 resources: Optional[Sequence[builtins.str]] = None,
                 verbs: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] api_groups: Policy rule api groups
        :param Sequence[builtins.str] non_resource_urls: Policy rule non resource urls
        :param Sequence[builtins.str] resource_names: Policy rule resource names
        :param Sequence[builtins.str] resources: Policy rule resources
        :param Sequence[builtins.str] verbs: Policy rule verbs
        """
        if api_groups is not None:
            pulumi.set(__self__, "api_groups", api_groups)
        if non_resource_urls is not None:
            pulumi.set(__self__, "non_resource_urls", non_resource_urls)
        if resource_names is not None:
            pulumi.set(__self__, "resource_names", resource_names)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)
        if verbs is not None:
            pulumi.set(__self__, "verbs", verbs)

    @property
    @pulumi.getter(name="apiGroups")
    def api_groups(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[builtins.str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


